diff --git a/go.mod b/go.mod index c1f30663d..82b845f40 100644 --- a/go.mod +++ b/go.mod @@ -19,10 +19,10 @@ require ( require ( github.com/alecthomas/kong v1.15.0 github.com/alicebob/miniredis/v2 v2.39.0 - github.com/aws/aws-sdk-go-v2 v1.47.1 + github.com/aws/aws-sdk-go-v2 v1.47.4 github.com/aws/aws-sdk-go-v2/config v1.33.6 github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.1 - github.com/aws/aws-sdk-go-v2/service/acm v1.38.3 + github.com/aws/aws-sdk-go-v2/service/acm v1.50.6 github.com/aws/aws-sdk-go-v2/service/dynamodb v1.69.1 github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.50.1 github.com/aws/aws-sdk-go-v2/service/ssm v1.68.5 @@ -40,8 +40,8 @@ require ( github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirect github.com/Microsoft/go-winio v0.6.2 // indirect github.com/aws/aws-sdk-go-v2/credentials v1.20.6 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.4 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.4 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.7 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.7 // indirect github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.4 // indirect github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 // indirect github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.13.4 // indirect @@ -50,7 +50,7 @@ require ( github.com/aws/aws-sdk-go-v2/service/sso v1.38.1 // indirect github.com/aws/aws-sdk-go-v2/service/ssooidc v1.43.1 // indirect github.com/aws/aws-sdk-go-v2/service/sts v1.51.1 // indirect - github.com/aws/smithy-go v1.28.1 // indirect + github.com/aws/smithy-go v1.28.6 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/cenkalti/backoff/v4 v4.3.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect diff --git a/go.sum b/go.sum index 245004b06..6a8a06665 100644 --- a/go.sum +++ b/go.sum @@ -27,22 +27,22 @@ github.com/armon/go-metrics v0.4.1 h1:hR91U9KYmb6bLBYLQjyM+3j+rcd/UhE+G78SFnF8gJ github.com/armon/go-metrics v0.4.1/go.mod h1:E6amYzXo6aW1tqzoZGT755KkbgrJsSdpwZ+3JqfkOG4= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= -github.com/aws/aws-sdk-go-v2 v1.47.1 h1:uOIZnp4PK3ZhKI0dNrJrhTEsLxbpXHTAJlwoS1pvAtw= -github.com/aws/aws-sdk-go-v2 v1.47.1/go.mod h1:bttEH6JqnUL8LepvDVfdrds/fZ5bCIxzpe3abyUrhDU= +github.com/aws/aws-sdk-go-v2 v1.47.4 h1:bTvk6UdSSSvaQsfLVj1JRDEEqj/PDRwGf1KanaRzau0= +github.com/aws/aws-sdk-go-v2 v1.47.4/go.mod h1:XkrjAZvr705Nytv6PkPUhoSB2W9+vVHBp5oAWpkh8Ak= github.com/aws/aws-sdk-go-v2/config v1.33.6 h1:MBjkSTLczek/UgiK+EYPIoRTqE7gP8vtW3OFbFo7Nug= github.com/aws/aws-sdk-go-v2/config v1.33.6/go.mod h1:grRAFzdAZJrwcbasJRg2MPvIrVjtlfXllHssN6+E1JE= github.com/aws/aws-sdk-go-v2/credentials v1.20.6 h1:NpAFXCU7NzXNkdGK3zQTtsRJ+3v9tZQV0xcdRw8uBdw= github.com/aws/aws-sdk-go-v2/credentials v1.20.6/go.mod h1:mcZCoiPnyMvP8VMNbygNX5lLqSlkYJIMPODylQMurOk= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.1 h1:8gALAAmacnIXh+z6VkdDanv4/IkG5APdg4DZLDTmLog= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.1/go.mod h1:Z7IJhJU+poOdJjUR2wpyY21ossQ1XS/R3Lk9Msq5kM4= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.4 h1:CLq4+8UHCI+ZZYl/EuJxXovaIVN2xeeT8JV+dsApQ5E= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.4/go.mod h1:Wv4q5sAM04xAMkoOedxLx2inVf6K5FdxYp+A61L+q/0= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.4 h1:dD4MR81I7YkpEBRk6UP9rocC2QnT3qVuXwzlYTtfGEs= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.4/go.mod h1:EcXV1kAFd5XwSkDHlj94gnF3q5CkJyYiIJfH8N0VmrE= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.7 h1:fSNAt6hs4qLjb9tMZc6vj3PHlOCYGXK2JjJZ7AW2tf4= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.7/go.mod h1:TMav+EuXQu5kNpZZz/6rIC8xx4mCsW+6AKHrjvOSAsE= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.7 h1:7NS6kqBjkWIN8P/AEdmtyq6eQGAhN1oHTZdzXclpH6Y= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.7/go.mod h1:1PFqtAUsIgF1nEVojzRJSf/v88zjzqrGW+w+UAtkXyQ= github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.4 h1:7Wo47d/xn/7KttCSBd8EGYeZ7ULRFRkUHr6vkZPBzVQ= github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.4/go.mod h1:tDB2IVC1xC3vX8o+6uRlzhTxP3g1b77CZXFX/oD2FnQ= -github.com/aws/aws-sdk-go-v2/service/acm v1.38.3 h1:Fzab84hCu3rw9R9Y3mH7SHfr/cSEHnCB0Mq1JCdr9t0= -github.com/aws/aws-sdk-go-v2/service/acm v1.38.3/go.mod h1:yCteizCNPaHt0SnNusoGGHvy0JDB0tvGDTVhEt5anZM= +github.com/aws/aws-sdk-go-v2/service/acm v1.50.6 h1:KPUbBMV2WsOLdx4EXjn+H20RNEZdZ0OnlfIQN3xod1s= +github.com/aws/aws-sdk-go-v2/service/acm v1.50.6/go.mod h1:dKnz1ijMd3vYf47vvDQ+cJzMIGguO57EsmvAhfa8lQo= github.com/aws/aws-sdk-go-v2/service/dynamodb v1.69.1 h1:bKwiQA6SKqFXBO+1IwP/hTwCU5RlqeitG4gVvSuMN8U= github.com/aws/aws-sdk-go-v2/service/dynamodb v1.69.1/go.mod h1:Gm+i2GlUsFNlzoBq8VXF44XHbKANn3tV8nYBBp3rN8Q= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 h1:bAdDl/HkGCcGPoe25ToSHEw23VIxt6CT5fLcg111BKg= @@ -63,8 +63,8 @@ github.com/aws/aws-sdk-go-v2/service/ssooidc v1.43.1 h1:orIWdNiLgzrhu/11RcPPKO/S github.com/aws/aws-sdk-go-v2/service/ssooidc v1.43.1/go.mod h1:skwM/xsbR/1ReUTesv9BhpJp1VjajR7DWQnuVLwiXsQ= github.com/aws/aws-sdk-go-v2/service/sts v1.51.1 h1:0HOqZXRvMytH6bFHVIc0oJX07sZjfhz0zXtjs6gdE8s= github.com/aws/aws-sdk-go-v2/service/sts v1.51.1/go.mod h1:26zA0GhDrLo+yiLI2yXWxqB1PdsShfLikoI7GOEgugM= -github.com/aws/smithy-go v1.28.1 h1:R/nXH00c8qcfCzQVELtRw+eLQWtzv+VAIEFJ1/xxXlQ= -github.com/aws/smithy-go v1.28.1/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= +github.com/aws/smithy-go v1.28.6 h1:Pj+/sUviNYjow8ELRtNwKHZ9ECeF+7pATX3+shjLIrw= +github.com/aws/smithy-go v1.28.6/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= 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 f0392825a..880875ae2 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.47.1" +const goModuleVersion = "1.47.4" 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 8f6c18348..e690de43f 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,17 @@ +# v1.5.7 (2026-10-22) + +* **Bug Fix**: Update smithy-go to v1.28.6 +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.5.6 (2026-10-09.2) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.5.5 (2026-10-08) + +* **Dependency Update**: Update to smithy-go v1.28.4. +* **Dependency Update**: Updated to the latest SDK module versions + # v1.5.4 (2026-09-24) * **Dependency Update**: Updated to the latest SDK module versions 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 744363f1e..67531933d 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.5.4" +const goModuleVersion = "1.5.7" 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 538b0e872..fabd3306a 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,17 @@ +# v2.8.7 (2026-10-22) + +* **Bug Fix**: Update smithy-go to v1.28.6 +* **Dependency Update**: Updated to the latest SDK module versions + +# v2.8.6 (2026-10-09.2) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v2.8.5 (2026-10-08) + +* **Dependency Update**: Update to smithy-go v1.28.4. +* **Dependency Update**: Updated to the latest SDK module versions + # v2.8.4 (2026-09-24) * **Dependency Update**: Updated to the latest SDK module versions 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 a9a325b93..4619ce116 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.8.4" +const goModuleVersion = "2.8.7" diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/CHANGELOG.md index b1b7b963c..b4a260d4c 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/CHANGELOG.md +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/CHANGELOG.md @@ -1,3 +1,164 @@ +# v1.50.6 (2026-10-22) + +* **Bug Fix**: Update smithy-go to v1.28.6 +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.50.5 (2026-10-19) + +* **Bug Fix**: Allow lists with null values to deserialize into its zero value instead of failing + +# v1.50.4 (2026-10-09.2) + +* **Dependency Update**: Update to smithy-go v1.28.5. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.50.3 (2026-10-08) + +* **Dependency Update**: Update to smithy-go v1.28.4. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.50.2 (2026-10-06) + +* No change notes available for this release. + +# v1.50.1 (2026-09-24) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.50.0 (2026-09-09) + +* **Feature**: Stop registering the `retry.MetricsHeader` middleware in generated clients. The `Amz-Sdk-Request` header is now set by the retry middleware itself. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.49.0 (2026-09-04) + +* **Feature**: Stop registering the `spanRetryLoop` middleware in generated clients. The retry loop's tracing span is now opened by the retry middleware itself. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.48.0 (2026-08-31.2) + +* **Feature**: Stop registering the `SetCredentialSourceMiddleware` middleware in generated clients. Credential source user agent features are now set when the client's middleware stack is constructed. + +# v1.47.0 (2026-08-31) + +* **Feature**: Enable schema-based (de)serialization for this service. + +# v1.46.1 (2026-08-28) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.46.0 (2026-08-27) + +* **Feature**: Support connection read timeouts in the SDK. This is currently available on an opt-in basis by setting env `AWS_ENABLE_DEFAULT_SOCKET_TIMEOUT_2026=true`. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.45.0 (2026-08-26) + +* **Feature**: Stop registering the `ComputeContentLength` middleware in generated clients. `Content-Length` is now set when the request body is set via `SetStream`. +* **Dependency Update**: Update to smithy-go v1.28.0. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.44.3 (2026-08-25) + +* **Dependency Update**: Update to smithy-go v1.27.10. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.44.2 (2026-08-20) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.44.1 (2026-08-14) + +* **Dependency Update**: Update to smithy-go v1.27.8. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.44.0 (2026-08-13) + +* **Feature**: This change allows customers to update their existing email-validated certificates to use the DNS validation method. + +# v1.43.5 (2026-08-10) + +* **Dependency Update**: Update to smithy-go v1.27.7. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.43.4 (2026-08-05) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.43.3 (2026-07-31.2) + +* **Dependency Update**: Updated to the latest SDK module versions +* **Dependency Update**: Upgrade to smithy-go v1.27.6 to fix various serde issues in HTTP binding services. + +# v1.43.2 (2026-07-29) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.43.1 (2026-07-28) + +* **Dependency Update**: Update to smithy-go v1.27.5. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.43.0 (2026-07-21) + +* **Feature**: Add an option to clients to disable clock skew +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.42.1 (2026-07-13) + +* No change notes available for this release. + +# v1.42.0 (2026-07-06) + +* **Feature**: Add request serialization snapshot tests. + +# v1.41.1 (2026-07-01) + +* **Bug Fix**: Bump smithy-go to 1.27.3, fix JSON encorder for document.Number, endpoint host label format validation and CBOR union serialization on new serde +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.41.0 (2026-06-30) + +* **Feature**: AWS Certificate Manager now supports the Automatic Certificate Management Environment (ACME) protocol to issue public certificates. ACME is an industry-standard protocol for automating certificate lifecycle on customer-managed infrastructure such as on-premises servers and Kubernetes clusters. + +# v1.40.1 (2026-06-29) + +* No change notes available for this release. + +# v1.40.0 (2026-06-12) + +* **Feature**: Certificate transparency logging opt-out is no longer available. Per compliance requirements, all public ACM certificates are automatically recorded in certificate transparency logs. The CertificateTransparencyLoggingPreference option is deprecated. + +# v1.39.6 (2026-06-08) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.39.5 (2026-06-04) + +* **Dependency Update**: Update to smithy-go v1.27.1 to fix several union-related deserialization bugs in schema-serde-enabled services. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.39.4 (2026-06-03) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.39.3 (2026-06-02) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.39.2 (2026-05-29) + +* **Dependency Update**: Update to smithy-go v1.26.0. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.39.1 (2026-05-28) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.39.0 (2026-05-21) + +* **Feature**: Adding new BDD representation of endpoint ruleset + # v1.38.3 (2026-04-29) * **Dependency Update**: Update to smithy-go v1.25.1. diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_client.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_client.go index c384b5154..aa1ef2cbd 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_client.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_client.go @@ -4,6 +4,7 @@ package acm import ( "context" + cryptorand "crypto/rand" "errors" "fmt" "github.com/aws/aws-sdk-go-v2/aws" @@ -15,13 +16,17 @@ import ( internalauth "github.com/aws/aws-sdk-go-v2/internal/auth" internalauthsmithy "github.com/aws/aws-sdk-go-v2/internal/auth/smithy" internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources" + "github.com/aws/aws-sdk-go-v2/internal/timeouts" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" smithy "github.com/aws/smithy-go" smithydocument "github.com/aws/smithy-go/document" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/metrics" "github.com/aws/smithy-go/middleware" + smithyrand "github.com/aws/smithy-go/rand" "github.com/aws/smithy-go/tracing" smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/transport/http/protocol/awsjson" "net" "net/http" "sync/atomic" @@ -202,6 +207,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + resolveIdempotencyTokenProvider(&options) + resolveEndpointResolverV2(&options) resolveTracerProvider(&options) @@ -210,6 +217,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveAuthSchemeResolver(&options) + options.Protocol = awsjson.New11(schemas.CertificateManager) + for _, fn := range optFns { fn(&options) } @@ -260,6 +269,14 @@ func (c *Client) invokeOperation( finalizeClientEndpointResolverOptions(&options) + ctx = setLoggerContext(ctx, options, opID) + + ctx = resolveServiceMetadata(ctx, options, opID) + + if err := c.addCommonMiddlewares(stack, options, opID); err != nil { + return nil, metadata, err + } + for _, fn := range stackFns { if err := fn(stack, options); err != nil { return nil, metadata, err @@ -364,6 +381,43 @@ func addProtocolFinalizerMiddlewares(stack *middleware.Stack, options Options, o } return nil } + +func (c *Client) addCommonMiddlewares(stack *middleware.Stack, options Options, operation string) error { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, operation); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + if err := addClientRequestID(stack); err != nil { + return err + } + if err := addRetry(stack, options, c); err != nil { + return err + } + if err := addRawResponseToMetadata(stack); err != nil { + return err + } + if err := addClientUserAgent(stack, options); err != nil { + return err + } + if err := addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err := addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err := addRecursionDetection(stack); err != nil { + return err + } + if err := addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err := addInterceptAttempt(stack, options); err != nil { + return err + } + return nil +} func resolveAuthSchemeResolver(options *Options) { if options.AuthSchemeResolver == nil { options.AuthSchemeResolver = &defaultAuthSchemeResolver{} @@ -382,32 +436,104 @@ func resolveAuthSchemes(options *Options) { } } -type noSmithyDocumentSerde = smithydocument.NoSerde - -type legacyEndpointContextSetter struct { - LegacyResolver EndpointResolver +type serializeRequestMiddleware struct { + options *Options + operationSchema *smithy.OperationSchema } -func (*legacyEndpointContextSetter) ID() string { - return "legacyEndpointContextSetter" +func (*serializeRequestMiddleware) ID() string { + return "OperationSerializer" } -func (m *legacyEndpointContextSetter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( - out middleware.InitializeOutput, metadata middleware.Metadata, err error, +func (m *serializeRequestMiddleware) HandleSerialize( + ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler, +) ( + middleware.SerializeOutput, middleware.Metadata, error, ) { - if m.LegacyResolver != nil { - ctx = awsmiddleware.SetRequiresLegacyEndpoints(ctx, true) + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return middleware.SerializeOutput{}, middleware.Metadata{}, fmt.Errorf("unexpected transport type %T", in.Request) } - return next.HandleInitialize(ctx, in) + input, ok := in.Parameters.(smithy.Serializable) + if !ok { + return middleware.SerializeOutput{}, middleware.Metadata{}, fmt.Errorf("input %T is not Serializable", in.Request) + } + + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + + err := m.options.Protocol.SerializeRequest(ctx, m.operationSchema, input, req) + + endTimer() + span.End() + + if err != nil { + return middleware.SerializeOutput{}, middleware.Metadata{}, err + } + return next.HandleSerialize(ctx, in) +} + +type deserializeResponseMiddleware struct { + options *Options + operationSchema *smithy.OperationSchema + output smithy.Deserializable } -func addlegacyEndpointContextSetter(stack *middleware.Stack, o Options) error { - return stack.Initialize.Add(&legacyEndpointContextSetter{ - LegacyResolver: o.EndpointResolver, - }, middleware.Before) + +func (*deserializeResponseMiddleware) ID() string { + return "OperationDeserializer" +} + +func (m *deserializeResponseMiddleware) HandleDeserialize( + ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler, +) ( + middleware.DeserializeOutput, middleware.Metadata, error, +) { + out, md, err := next.HandleDeserialize(ctx, in) + + resp, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + if err != nil { + // Transport-level failure with no HTTP response to close. + return out, md, err + } + return out, md, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + // Close the response body on return. CloseResponseBody keeps the body + // open only for a successful caller-owned stream (a streaming payload + // with a nil error); on any error -- including one surfaced by an + // interceptor that runs after OperationDeserializer (after transmit or + // before deserialization) -- it closes the received body. Registering + // this before the error check below is what covers those interceptor + // aborts. Event streams close their own body in the event stream + // deserializer. + if !m.operationSchema.IsInputEventStream() && !m.operationSchema.IsOutputEventStream() { + _, isStreamingPayload := m.output.(smithy.StreamingOutput) + defer func() { + smithyhttp.CloseResponseBody(ctx, resp, isStreamingPayload, err) + }() + } + + if err != nil { + return out, md, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + + err = m.options.Protocol.DeserializeResponse(ctx, m.operationSchema, TypeRegistry, resp, m.output) + out.Result = m.output + + endTimer() + span.End() + + return out, md, err } +type noSmithyDocumentSerde = smithydocument.NoSerde + func resolveDefaultLogger(o *Options) { if o.Logger != nil { return @@ -415,8 +541,9 @@ func resolveDefaultLogger(o *Options) { o.Logger = logging.Nop{} } -func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { - return middleware.AddSetLoggerMiddleware(stack, o.Logger) +func setLoggerContext(ctx context.Context, options Options, operation string) context.Context { + _ = operation + return middleware.SetLogger(ctx, options.Logger) } func setResolvedDefaultsMode(o *Options) { @@ -437,16 +564,17 @@ func setResolvedDefaultsMode(o *Options) { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - DefaultsMode: cfg.DefaultsMode, - RuntimeEnvironment: cfg.RuntimeEnvironment, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, - AppID: cfg.AppID, - AuthSchemePreference: cfg.AuthSchemePreference, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, + AppID: cfg.AppID, + DisableClockSkewCorrection: cfg.DisableClockSkewCorrection, + AuthSchemePreference: cfg.AuthSchemePreference, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSRetryMaxAttempts(cfg, &opts) @@ -494,6 +622,12 @@ func resolveHTTPClient(o *Options) { }) } + if _, ok := buildable.GetReadTimeout(); !ok { + if timeout, ok := timeouts.GetServiceReadTimeout(ServiceID); ok { + buildable = buildable.WithReadTimeout(timeout) + } + } + o.HTTPClient = buildable } @@ -635,40 +769,14 @@ func addClientRequestID(stack *middleware.Stack) error { return stack.Build.Add(&awsmiddleware.ClientRequestID{}, middleware.After) } -func addComputeContentLength(stack *middleware.Stack) error { - return stack.Build.Add(&smithyhttp.ComputeContentLength{}, middleware.After) -} - func addRawResponseToMetadata(stack *middleware.Stack) error { return stack.Deserialize.Add(&awsmiddleware.AddRawResponse{}, middleware.Before) } -func addRecordResponseTiming(stack *middleware.Stack) error { - return stack.Deserialize.Add(&awsmiddleware.RecordResponseTiming{}, middleware.After) -} - -func addSpanRetryLoop(stack *middleware.Stack, options Options) error { - return stack.Finalize.Insert(&spanRetryLoop{options: options}, "Retry", middleware.Before) -} - -type spanRetryLoop struct { - options Options -} - -func (*spanRetryLoop) ID() string { - return "spanRetryLoop" -} - -func (m *spanRetryLoop) HandleFinalize( - ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler, -) ( - middleware.FinalizeOutput, middleware.Metadata, error, -) { - tracer := operationTracer(m.options.TracerProvider) - ctx, span := tracer.StartSpan(ctx, "RetryLoop") - defer span.End() - - return next.HandleFinalize(ctx, in) +func addRecordResponseTiming(stack *middleware.Stack, options Options) error { + return stack.Deserialize.Add(&awsmiddleware.RecordResponseTiming{ + DisableClockSkewCorrection: options.DisableClockSkewCorrection, + }, middleware.After) } func addStreamingEventsPayload(stack *middleware.Stack) error { return stack.Finalize.Add(&v4.StreamingEventsPayload{}, middleware.Before) @@ -710,18 +818,23 @@ func addIsPaginatorUserAgent(o *Options) { }) } +func resolveIdempotencyTokenProvider(o *Options) { + if o.IdempotencyTokenProvider != nil { + return + } + o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader) +} + func addRetry(stack *middleware.Stack, o Options, c *Client) error { attempt := retry.NewAttemptMiddleware(o.Retryer, smithyhttp.RequestCloner, func(m *retry.Attempt) { m.LogAttempts = o.ClientLogMode.IsRetries() m.OperationMeter = o.MeterProvider.Meter("github.com/aws/aws-sdk-go-v2/service/acm") m.ClientSkew = c.timeOffset + m.DisableClockSkewCorrection = o.DisableClockSkewCorrection }) if err := stack.Finalize.Insert(attempt, "ResolveAuthScheme", middleware.Before); err != nil { return err } - if err := stack.Finalize.Insert(&retry.MetricsHeader{}, attempt.ID(), middleware.After); err != nil { - return err - } return nil } @@ -774,35 +887,21 @@ func addUserAgentRetryMode(stack *middleware.Stack, options Options) error { return nil } -type setCredentialSourceMiddleware struct { - ua *awsmiddleware.RequestUserAgent - options Options -} - -func (m setCredentialSourceMiddleware) ID() string { return "SetCredentialSourceMiddleware" } - -func (m setCredentialSourceMiddleware) HandleBuild(ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler) ( - out middleware.BuildOutput, metadata middleware.Metadata, err error, -) { - asProviderSource, ok := m.options.Credentials.(aws.CredentialProviderSource) - if !ok { - return next.HandleBuild(ctx, in) - } - providerSources := asProviderSource.ProviderSources() - for _, source := range providerSources { - m.ua.AddCredentialsSource(source) - } - return next.HandleBuild(ctx, in) -} - func addCredentialSource(stack *middleware.Stack, options Options) error { ua, err := getOrAddRequestUserAgent(stack) if err != nil { return err } - mw := setCredentialSourceMiddleware{ua: ua, options: options} - return stack.Build.Insert(&mw, "UserAgent", middleware.Before) + asProviderSource, ok := options.Credentials.(aws.CredentialProviderSource) + if !ok { + return nil + } + + for _, source := range asProviderSource.ProviderSources() { + ua.AddCredentialsSource(source) + } + return nil } func resolveTracerProvider(options *Options) { @@ -817,6 +916,23 @@ func resolveMeterProvider(options *Options) { } } +// IdempotencyTokenProvider interface for providing idempotency token +type IdempotencyTokenProvider interface { + GetIdempotencyToken() (string, error) +} + +func resolveServiceMetadata(ctx context.Context, options Options, operation string) context.Context { + ctx = awsmiddleware.SetServiceID(ctx, ServiceID) + if options.Region != "" { + ctx = awsmiddleware.SetRegion(ctx, options.Region) + } + ctx = awsmiddleware.SetOperationName(ctx, operation) + if options.EndpointResolver != nil { + ctx = awsmiddleware.SetRequiresLegacyEndpoints(ctx, true) + } + return ctx +} + func addRecursionDetection(stack *middleware.Stack) error { return stack.Build.Add(&awsmiddleware.RecursionDetection{}, middleware.After) } diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_AddTagsToCertificate.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_AddTagsToCertificate.go index eb3092d91..c5bb94d61 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_AddTagsToCertificate.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_AddTagsToCertificate.go @@ -4,11 +4,11 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Adds one or more tags to an ACM certificate. Tags are labels that you can use @@ -16,6 +16,9 @@ import ( // of a key and an optional value . You specify the certificate on input by its // Amazon Resource Name (ARN). You specify the tag by using a key-value pair. // +// This action applies only to the certificate resource type. For all other ACM +// resource types, use TagResourceinstead. +// // You can apply a tag to just one certificate if you want to identify a specific // characteristic of that certificate, or you can apply the same tag to multiple // certificates if you want to filter for a common relationship among those @@ -66,6 +69,23 @@ type AddTagsToCertificateInput struct { noSmithyDocumentSerde } +func (v *AddTagsToCertificateInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.AddTagsToCertificateRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *AddTagsToCertificateInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.AddTagsToCertificateRequest_CertificateArn, *v.CertificateArn) + } + serializeTagList(s, schemas.AddTagsToCertificateRequest_Tags, v.Tags) +} +func (in *AddTagsToCertificateInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type AddTagsToCertificateOutput struct { // Metadata pertaining to the operation's result. ResultMetadata middleware.Metadata @@ -73,65 +93,36 @@ type AddTagsToCertificateOutput struct { noSmithyDocumentSerde } +func (v *AddTagsToCertificateOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *AddTagsToCertificateOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *AddTagsToCertificateOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} func (c *Client) addOperationAddTagsToCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpAddTagsToCertificate{}, middleware.After) - if err != nil { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.AddTagsToCertificate, schemas.AddTagsToCertificateRequest, nil)}, middleware.After); err != nil { return err } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpAddTagsToCertificate{}, middleware.After) - if err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.AddTagsToCertificate, schemas.AddTagsToCertificateRequest, nil), output: &AddTagsToCertificateOutput{}}, middleware.After); err != nil { return err } - if err := addProtocolFinalizerMiddlewares(stack, options, "AddTagsToCertificate"); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -140,12 +131,6 @@ func (c *Client) addOperationAddTagsToCertificateMiddlewares(stack *middleware.S if err = addOpAddTagsToCertificateValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAddTagsToCertificate(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -158,22 +143,8 @@ func (c *Client) addOperationAddTagsToCertificateMiddlewares(stack *middleware.S 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 } - -func newServiceMetadataMiddleware_opAddTagsToCertificate(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "AddTagsToCertificate", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_CreateAcmeDomainValidation.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_CreateAcmeDomainValidation.go new file mode 100644 index 000000000..813bdf584 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_CreateAcmeDomainValidation.go @@ -0,0 +1,192 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Creates a domain validation for an ACME endpoint. Domain validations authorize +// the endpoint to issue certificates for specified domain names. You configure +// prevalidation to prove domain ownership. +func (c *Client) CreateAcmeDomainValidation(ctx context.Context, params *CreateAcmeDomainValidationInput, optFns ...func(*Options)) (*CreateAcmeDomainValidationOutput, error) { + if params == nil { + params = &CreateAcmeDomainValidationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateAcmeDomainValidation", params, optFns, c.addOperationCreateAcmeDomainValidationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateAcmeDomainValidationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateAcmeDomainValidationInput struct { + + // The Amazon Resource Name (ARN) of the ACME endpoint. + // + // This member is required. + AcmeEndpointArn *string + + // The domain name to validate. + // + // This member is required. + DomainName *string + + // The prevalidation options for the domain. + // + // This member is required. + PrevalidationOptions types.PrevalidationOptions + + // A unique, case-sensitive identifier to ensure idempotency of the request. + IdempotencyToken *string + + // One or more tags to associate with the domain validation. + Tags []types.Tag + + noSmithyDocumentSerde +} + +func (v *CreateAcmeDomainValidationInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CreateAcmeDomainValidationRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CreateAcmeDomainValidationInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.CreateAcmeDomainValidationRequest_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.DomainName != nil { + s.WriteString(schemas.CreateAcmeDomainValidationRequest_DomainName, *v.DomainName) + } + if v.IdempotencyToken != nil { + s.WriteString(schemas.CreateAcmeDomainValidationRequest_IdempotencyToken, *v.IdempotencyToken) + } + serializePrevalidationOptions(s, schemas.CreateAcmeDomainValidationRequest_PrevalidationOptions, v.PrevalidationOptions) + serializeTagList(s, schemas.CreateAcmeDomainValidationRequest_Tags, v.Tags) +} +func (in *CreateAcmeDomainValidationInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type CreateAcmeDomainValidationOutput struct { + + // The Amazon Resource Name (ARN) of the created domain validation. + // + // This member is required. + AcmeDomainValidationArn *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *CreateAcmeDomainValidationOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CreateAcmeDomainValidationResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CreateAcmeDomainValidationOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeDomainValidationArn != nil { + s.WriteString(schemas.CreateAcmeDomainValidationResponse_AcmeDomainValidationArn, *v.AcmeDomainValidationArn) + } +} +func (v *CreateAcmeDomainValidationOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.CreateAcmeDomainValidationResponse, func(s *smithy.Schema) error { + switch s { + case schemas.CreateAcmeDomainValidationResponse_AcmeDomainValidationArn: + v.AcmeDomainValidationArn = new(string) + return d.ReadString(schemas.CreateAcmeDomainValidationResponse_AcmeDomainValidationArn, v.AcmeDomainValidationArn) + } + return nil + }) +} +func (c *Client) addOperationCreateAcmeDomainValidationMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.CreateAcmeDomainValidation, schemas.CreateAcmeDomainValidationRequest, schemas.CreateAcmeDomainValidationResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.CreateAcmeDomainValidation, schemas.CreateAcmeDomainValidationRequest, schemas.CreateAcmeDomainValidationResponse), output: &CreateAcmeDomainValidationOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addIdempotencyToken_opCreateAcmeDomainValidationMiddleware(stack, options); err != nil { + return err + } + if err = addOpCreateAcmeDomainValidationValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +type idempotencyToken_initializeOpCreateAcmeDomainValidation struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateAcmeDomainValidation) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateAcmeDomainValidation) 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.(*CreateAcmeDomainValidationInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateAcmeDomainValidationInput ") + } + + if input.IdempotencyToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.IdempotencyToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateAcmeDomainValidationMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateAcmeDomainValidation{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_CreateAcmeEndpoint.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_CreateAcmeEndpoint.go new file mode 100644 index 000000000..4ba22272a --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_CreateAcmeEndpoint.go @@ -0,0 +1,194 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Creates an ACME endpoint, which is a managed ACME server with a unique endpoint +// URL. After creation, ACME clients can use the endpoint URL to automate +// certificate issuance using the ACME protocol. +func (c *Client) CreateAcmeEndpoint(ctx context.Context, params *CreateAcmeEndpointInput, optFns ...func(*Options)) (*CreateAcmeEndpointOutput, error) { + if params == nil { + params = &CreateAcmeEndpointInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateAcmeEndpoint", params, optFns, c.addOperationCreateAcmeEndpointMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateAcmeEndpointOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateAcmeEndpointInput struct { + + // The authorization behavior for the ACME endpoint. + // + // This member is required. + AuthorizationBehavior types.AcmeAuthorizationBehavior + + // The type of certificate authority to use for issuing certificates through this + // ACME endpoint. + // + // This member is required. + CertificateAuthority types.CertificateAuthority + + // Tags to apply to certificates issued through this ACME endpoint. + CertificateTags []types.Tag + + // Specifies whether ACME clients must provide contact information during account + // registration. + Contact types.AcmeContact + + // A unique, case-sensitive identifier to ensure idempotency of the request. + IdempotencyToken *string + + // One or more tags to associate with the ACME endpoint. + Tags []types.Tag + + noSmithyDocumentSerde +} + +func (v *CreateAcmeEndpointInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CreateAcmeEndpointRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CreateAcmeEndpointInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AuthorizationBehavior != "" { + s.WriteString(schemas.CreateAcmeEndpointRequest_AuthorizationBehavior, string(v.AuthorizationBehavior)) + } + serializeCertificateAuthority(s, schemas.CreateAcmeEndpointRequest_CertificateAuthority, v.CertificateAuthority) + serializeTagList(s, schemas.CreateAcmeEndpointRequest_CertificateTags, v.CertificateTags) + if v.Contact != "" { + s.WriteString(schemas.CreateAcmeEndpointRequest_Contact, string(v.Contact)) + } + if v.IdempotencyToken != nil { + s.WriteString(schemas.CreateAcmeEndpointRequest_IdempotencyToken, *v.IdempotencyToken) + } + serializeTagList(s, schemas.CreateAcmeEndpointRequest_Tags, v.Tags) +} +func (in *CreateAcmeEndpointInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type CreateAcmeEndpointOutput struct { + + // The Amazon Resource Name (ARN) of the created ACME endpoint. + AcmeEndpointArn *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *CreateAcmeEndpointOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CreateAcmeEndpointResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CreateAcmeEndpointOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.CreateAcmeEndpointResponse_AcmeEndpointArn, *v.AcmeEndpointArn) + } +} +func (v *CreateAcmeEndpointOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.CreateAcmeEndpointResponse, func(s *smithy.Schema) error { + switch s { + case schemas.CreateAcmeEndpointResponse_AcmeEndpointArn: + v.AcmeEndpointArn = new(string) + return d.ReadString(schemas.CreateAcmeEndpointResponse_AcmeEndpointArn, v.AcmeEndpointArn) + } + return nil + }) +} +func (c *Client) addOperationCreateAcmeEndpointMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.CreateAcmeEndpoint, schemas.CreateAcmeEndpointRequest, schemas.CreateAcmeEndpointResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.CreateAcmeEndpoint, schemas.CreateAcmeEndpointRequest, schemas.CreateAcmeEndpointResponse), output: &CreateAcmeEndpointOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addIdempotencyToken_opCreateAcmeEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addOpCreateAcmeEndpointValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +type idempotencyToken_initializeOpCreateAcmeEndpoint struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateAcmeEndpoint) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateAcmeEndpoint) 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.(*CreateAcmeEndpointInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateAcmeEndpointInput ") + } + + if input.IdempotencyToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.IdempotencyToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateAcmeEndpointMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateAcmeEndpoint{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_CreateAcmeExternalAccountBinding.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_CreateAcmeExternalAccountBinding.go new file mode 100644 index 000000000..bbd07e46f --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_CreateAcmeExternalAccountBinding.go @@ -0,0 +1,196 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Creates an external account binding (EAB) for an ACME endpoint. An EAB provides +// credentials that authorize an ACME client to register an account with the +// endpoint. Each EAB is associated with an IAM role that controls what certificate +// operations the ACME client can perform. +func (c *Client) CreateAcmeExternalAccountBinding(ctx context.Context, params *CreateAcmeExternalAccountBindingInput, optFns ...func(*Options)) (*CreateAcmeExternalAccountBindingOutput, error) { + if params == nil { + params = &CreateAcmeExternalAccountBindingInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateAcmeExternalAccountBinding", params, optFns, c.addOperationCreateAcmeExternalAccountBindingMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateAcmeExternalAccountBindingOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateAcmeExternalAccountBindingInput struct { + + // The Amazon Resource Name (ARN) of the ACME endpoint. + // + // This member is required. + AcmeEndpointArn *string + + // The Amazon Resource Name (ARN) of the IAM role to associate with the external + // account binding. + // + // This member is required. + RoleArn *string + + // The expiration configuration for the external account binding. + Expiration *types.Expiration + + // A unique, case-sensitive identifier to ensure idempotency of the request. + IdempotencyToken *string + + // One or more tags to associate with the external account binding. + Tags []types.Tag + + noSmithyDocumentSerde +} + +func (v *CreateAcmeExternalAccountBindingInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CreateAcmeExternalAccountBindingRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CreateAcmeExternalAccountBindingInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.CreateAcmeExternalAccountBindingRequest_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.Expiration != nil { + s.WriteStruct(schemas.CreateAcmeExternalAccountBindingRequest_Expiration) + v.Expiration.SerializeMembers(s) + s.CloseStruct() + } + if v.IdempotencyToken != nil { + s.WriteString(schemas.CreateAcmeExternalAccountBindingRequest_IdempotencyToken, *v.IdempotencyToken) + } + if v.RoleArn != nil { + s.WriteString(schemas.CreateAcmeExternalAccountBindingRequest_RoleArn, *v.RoleArn) + } + serializeTagList(s, schemas.CreateAcmeExternalAccountBindingRequest_Tags, v.Tags) +} +func (in *CreateAcmeExternalAccountBindingInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type CreateAcmeExternalAccountBindingOutput struct { + + // The created external account binding. + ExternalAccountBinding *types.AcmeExternalAccountBinding + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *CreateAcmeExternalAccountBindingOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CreateAcmeExternalAccountBindingResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CreateAcmeExternalAccountBindingOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.ExternalAccountBinding != nil { + s.WriteStruct(schemas.CreateAcmeExternalAccountBindingResponse_ExternalAccountBinding) + v.ExternalAccountBinding.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *CreateAcmeExternalAccountBindingOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.CreateAcmeExternalAccountBindingResponse, func(s *smithy.Schema) error { + switch s { + case schemas.CreateAcmeExternalAccountBindingResponse_ExternalAccountBinding: + v.ExternalAccountBinding = &types.AcmeExternalAccountBinding{} + return v.ExternalAccountBinding.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationCreateAcmeExternalAccountBindingMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.CreateAcmeExternalAccountBinding, schemas.CreateAcmeExternalAccountBindingRequest, schemas.CreateAcmeExternalAccountBindingResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.CreateAcmeExternalAccountBinding, schemas.CreateAcmeExternalAccountBindingRequest, schemas.CreateAcmeExternalAccountBindingResponse), output: &CreateAcmeExternalAccountBindingOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addIdempotencyToken_opCreateAcmeExternalAccountBindingMiddleware(stack, options); err != nil { + return err + } + if err = addOpCreateAcmeExternalAccountBindingValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +type idempotencyToken_initializeOpCreateAcmeExternalAccountBinding struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateAcmeExternalAccountBinding) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateAcmeExternalAccountBinding) 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.(*CreateAcmeExternalAccountBindingInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateAcmeExternalAccountBindingInput ") + } + + if input.IdempotencyToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.IdempotencyToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateAcmeExternalAccountBindingMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateAcmeExternalAccountBinding{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DeleteAcmeDomainValidation.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DeleteAcmeDomainValidation.go new file mode 100644 index 000000000..f3921816e --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DeleteAcmeDomainValidation.go @@ -0,0 +1,117 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Deletes a domain validation. After deletion, the ACME endpoint can no longer +// issue certificates for the associated domain. +func (c *Client) DeleteAcmeDomainValidation(ctx context.Context, params *DeleteAcmeDomainValidationInput, optFns ...func(*Options)) (*DeleteAcmeDomainValidationOutput, error) { + if params == nil { + params = &DeleteAcmeDomainValidationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteAcmeDomainValidation", params, optFns, c.addOperationDeleteAcmeDomainValidationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteAcmeDomainValidationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteAcmeDomainValidationInput struct { + + // The Amazon Resource Name (ARN) of the ACME domain validation to delete. + // + // This member is required. + AcmeDomainValidationArn *string + + noSmithyDocumentSerde +} + +func (v *DeleteAcmeDomainValidationInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DeleteAcmeDomainValidationRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DeleteAcmeDomainValidationInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeDomainValidationArn != nil { + s.WriteString(schemas.DeleteAcmeDomainValidationRequest_AcmeDomainValidationArn, *v.AcmeDomainValidationArn) + } +} +func (in *DeleteAcmeDomainValidationInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type DeleteAcmeDomainValidationOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *DeleteAcmeDomainValidationOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DeleteAcmeDomainValidationOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *DeleteAcmeDomainValidationOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} +func (c *Client) addOperationDeleteAcmeDomainValidationMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DeleteAcmeDomainValidation, schemas.DeleteAcmeDomainValidationRequest, nil)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DeleteAcmeDomainValidation, schemas.DeleteAcmeDomainValidationRequest, nil), output: &DeleteAcmeDomainValidationOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDeleteAcmeDomainValidationValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DeleteAcmeEndpoint.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DeleteAcmeEndpoint.go new file mode 100644 index 000000000..869fc1ade --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DeleteAcmeEndpoint.go @@ -0,0 +1,119 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Deletes an ACME endpoint. After deletion, the endpoint URL is no longer +// accessible and ACME clients cannot issue certificates through it. Any existing +// external account bindings and domain validations associated with the endpoint +// are also deleted. +func (c *Client) DeleteAcmeEndpoint(ctx context.Context, params *DeleteAcmeEndpointInput, optFns ...func(*Options)) (*DeleteAcmeEndpointOutput, error) { + if params == nil { + params = &DeleteAcmeEndpointInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteAcmeEndpoint", params, optFns, c.addOperationDeleteAcmeEndpointMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteAcmeEndpointOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteAcmeEndpointInput struct { + + // The Amazon Resource Name (ARN) of the ACME endpoint to delete. + // + // This member is required. + AcmeEndpointArn *string + + noSmithyDocumentSerde +} + +func (v *DeleteAcmeEndpointInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DeleteAcmeEndpointRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DeleteAcmeEndpointInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.DeleteAcmeEndpointRequest_AcmeEndpointArn, *v.AcmeEndpointArn) + } +} +func (in *DeleteAcmeEndpointInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type DeleteAcmeEndpointOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *DeleteAcmeEndpointOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DeleteAcmeEndpointOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *DeleteAcmeEndpointOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} +func (c *Client) addOperationDeleteAcmeEndpointMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DeleteAcmeEndpoint, schemas.DeleteAcmeEndpointRequest, nil)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DeleteAcmeEndpoint, schemas.DeleteAcmeEndpointRequest, nil), output: &DeleteAcmeEndpointOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDeleteAcmeEndpointValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DeleteAcmeExternalAccountBinding.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DeleteAcmeExternalAccountBinding.go new file mode 100644 index 000000000..f5e6cc36a --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DeleteAcmeExternalAccountBinding.go @@ -0,0 +1,118 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Deletes an external account binding. Previously fetched credentials for this +// binding will no longer be usable for account registration. A deleted binding +// cannot be recovered. +func (c *Client) DeleteAcmeExternalAccountBinding(ctx context.Context, params *DeleteAcmeExternalAccountBindingInput, optFns ...func(*Options)) (*DeleteAcmeExternalAccountBindingOutput, error) { + if params == nil { + params = &DeleteAcmeExternalAccountBindingInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteAcmeExternalAccountBinding", params, optFns, c.addOperationDeleteAcmeExternalAccountBindingMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteAcmeExternalAccountBindingOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteAcmeExternalAccountBindingInput struct { + + // The Amazon Resource Name (ARN) of the ACME external account binding to delete. + // + // This member is required. + AcmeExternalAccountBindingArn *string + + noSmithyDocumentSerde +} + +func (v *DeleteAcmeExternalAccountBindingInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DeleteAcmeExternalAccountBindingRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DeleteAcmeExternalAccountBindingInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeExternalAccountBindingArn != nil { + s.WriteString(schemas.DeleteAcmeExternalAccountBindingRequest_AcmeExternalAccountBindingArn, *v.AcmeExternalAccountBindingArn) + } +} +func (in *DeleteAcmeExternalAccountBindingInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type DeleteAcmeExternalAccountBindingOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *DeleteAcmeExternalAccountBindingOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DeleteAcmeExternalAccountBindingOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *DeleteAcmeExternalAccountBindingOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} +func (c *Client) addOperationDeleteAcmeExternalAccountBindingMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DeleteAcmeExternalAccountBinding, schemas.DeleteAcmeExternalAccountBindingRequest, nil)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DeleteAcmeExternalAccountBinding, schemas.DeleteAcmeExternalAccountBindingRequest, nil), output: &DeleteAcmeExternalAccountBindingOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDeleteAcmeExternalAccountBindingValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DeleteCertificate.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DeleteCertificate.go index 1cff0dfa4..9dd314b0c 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DeleteCertificate.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DeleteCertificate.go @@ -4,10 +4,10 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Deletes a certificate and its associated private key. If this action succeeds, @@ -26,6 +26,9 @@ import ( // deleted. For more information, see [Deleting Your Private CA]in the Private Certificate Authority User // Guide. // +// You cannot delete a certificate with a CertificateKeyPairOrigin of ACME . ACM +// automatically deletes these certificates 1 year after they expire. +// // Deleting a certificate issued by a private certificate authority (CA) has no // effect on the CA. You will continue to be charged for the CA until it is // deleted. For more information, see [Deleting your private CA]in the Amazon Web Services Private @@ -65,6 +68,22 @@ type DeleteCertificateInput struct { noSmithyDocumentSerde } +func (v *DeleteCertificateInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DeleteCertificateRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DeleteCertificateInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.DeleteCertificateRequest_CertificateArn, *v.CertificateArn) + } +} +func (in *DeleteCertificateInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type DeleteCertificateOutput struct { // Metadata pertaining to the operation's result. ResultMetadata middleware.Metadata @@ -72,65 +91,36 @@ type DeleteCertificateOutput struct { noSmithyDocumentSerde } +func (v *DeleteCertificateOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DeleteCertificateOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *DeleteCertificateOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} func (c *Client) addOperationDeleteCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteCertificate{}, middleware.After) - if err != nil { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DeleteCertificate, schemas.DeleteCertificateRequest, nil)}, middleware.After); err != nil { return err } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteCertificate{}, middleware.After) - if err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DeleteCertificate, schemas.DeleteCertificateRequest, nil), output: &DeleteCertificateOutput{}}, middleware.After); err != nil { return err } - if err := addProtocolFinalizerMiddlewares(stack, options, "DeleteCertificate"); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -139,12 +129,6 @@ func (c *Client) addOperationDeleteCertificateMiddlewares(stack *middleware.Stac if err = addOpDeleteCertificateValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteCertificate(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -157,22 +141,8 @@ func (c *Client) addOperationDeleteCertificateMiddlewares(stack *middleware.Stac 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 } - -func newServiceMetadataMiddleware_opDeleteCertificate(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "DeleteCertificate", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeAcmeAccount.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeAcmeAccount.go new file mode 100644 index 000000000..809016d28 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeAcmeAccount.go @@ -0,0 +1,138 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Returns detailed metadata about the specified ACME account, including its +// status, public key thumbprint, and associated external account binding. +func (c *Client) DescribeAcmeAccount(ctx context.Context, params *DescribeAcmeAccountInput, optFns ...func(*Options)) (*DescribeAcmeAccountOutput, error) { + if params == nil { + params = &DescribeAcmeAccountInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeAcmeAccount", params, optFns, c.addOperationDescribeAcmeAccountMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeAcmeAccountOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeAcmeAccountInput struct { + + // The URL of the ACME account. + // + // This member is required. + AccountUrl *string + + // The Amazon Resource Name (ARN) of the ACME endpoint. + // + // This member is required. + AcmeEndpointArn *string + + noSmithyDocumentSerde +} + +func (v *DescribeAcmeAccountInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeAcmeAccountRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeAcmeAccountInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AccountUrl != nil { + s.WriteString(schemas.DescribeAcmeAccountRequest_AccountUrl, *v.AccountUrl) + } + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.DescribeAcmeAccountRequest_AcmeEndpointArn, *v.AcmeEndpointArn) + } +} +func (in *DescribeAcmeAccountInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type DescribeAcmeAccountOutput struct { + + // The ACME account details. + AcmeAccount *types.AcmeAccount + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *DescribeAcmeAccountOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeAcmeAccountResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeAcmeAccountOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeAccount != nil { + s.WriteStruct(schemas.DescribeAcmeAccountResponse_AcmeAccount) + v.AcmeAccount.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *DescribeAcmeAccountOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DescribeAcmeAccountResponse, func(s *smithy.Schema) error { + switch s { + case schemas.DescribeAcmeAccountResponse_AcmeAccount: + v.AcmeAccount = &types.AcmeAccount{} + return v.AcmeAccount.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationDescribeAcmeAccountMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeAcmeAccount, schemas.DescribeAcmeAccountRequest, schemas.DescribeAcmeAccountResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeAcmeAccount, schemas.DescribeAcmeAccountRequest, schemas.DescribeAcmeAccountResponse), output: &DescribeAcmeAccountOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDescribeAcmeAccountValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeAcmeDomainValidation.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeAcmeDomainValidation.go new file mode 100644 index 000000000..2e353ca06 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeAcmeDomainValidation.go @@ -0,0 +1,548 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" + smithytime "github.com/aws/smithy-go/time" + smithywaiter "github.com/aws/smithy-go/waiter" + "time" +) + +// Returns detailed metadata about the specified domain validation, including its +// status, domain scope, and DNS resource records required for validation. +func (c *Client) DescribeAcmeDomainValidation(ctx context.Context, params *DescribeAcmeDomainValidationInput, optFns ...func(*Options)) (*DescribeAcmeDomainValidationOutput, error) { + if params == nil { + params = &DescribeAcmeDomainValidationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeAcmeDomainValidation", params, optFns, c.addOperationDescribeAcmeDomainValidationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeAcmeDomainValidationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeAcmeDomainValidationInput struct { + + // The Amazon Resource Name (ARN) of the ACME domain validation. + // + // This member is required. + AcmeDomainValidationArn *string + + noSmithyDocumentSerde +} + +func (v *DescribeAcmeDomainValidationInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeAcmeDomainValidationRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeAcmeDomainValidationInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeDomainValidationArn != nil { + s.WriteString(schemas.DescribeAcmeDomainValidationRequest_AcmeDomainValidationArn, *v.AcmeDomainValidationArn) + } +} +func (in *DescribeAcmeDomainValidationInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type DescribeAcmeDomainValidationOutput struct { + + // The ACME domain validation details. + AcmeDomainValidation *types.AcmeDomainValidation + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *DescribeAcmeDomainValidationOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeAcmeDomainValidationResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeAcmeDomainValidationOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeDomainValidation != nil { + s.WriteStruct(schemas.DescribeAcmeDomainValidationResponse_AcmeDomainValidation) + v.AcmeDomainValidation.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *DescribeAcmeDomainValidationOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DescribeAcmeDomainValidationResponse, func(s *smithy.Schema) error { + switch s { + case schemas.DescribeAcmeDomainValidationResponse_AcmeDomainValidation: + v.AcmeDomainValidation = &types.AcmeDomainValidation{} + return v.AcmeDomainValidation.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationDescribeAcmeDomainValidationMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeAcmeDomainValidation, schemas.DescribeAcmeDomainValidationRequest, schemas.DescribeAcmeDomainValidationResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeAcmeDomainValidation, schemas.DescribeAcmeDomainValidationRequest, schemas.DescribeAcmeDomainValidationResponse), output: &DescribeAcmeDomainValidationOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDescribeAcmeDomainValidationValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// AcmeDomainValidationValidatedWaiterOptions are waiter options for +// AcmeDomainValidationValidatedWaiter +type AcmeDomainValidationValidatedWaiterOptions 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, + // AcmeDomainValidationValidatedWaiter will use default minimum delay of 5 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, AcmeDomainValidationValidatedWaiter will use default max delay of + // 300 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, *DescribeAcmeDomainValidationInput, *DescribeAcmeDomainValidationOutput, error) (bool, error) +} + +// AcmeDomainValidationValidatedWaiter defines the waiters for +// AcmeDomainValidationValidated +type AcmeDomainValidationValidatedWaiter struct { + client DescribeAcmeDomainValidationAPIClient + + options AcmeDomainValidationValidatedWaiterOptions +} + +// NewAcmeDomainValidationValidatedWaiter constructs a +// AcmeDomainValidationValidatedWaiter. +func NewAcmeDomainValidationValidatedWaiter(client DescribeAcmeDomainValidationAPIClient, optFns ...func(*AcmeDomainValidationValidatedWaiterOptions)) *AcmeDomainValidationValidatedWaiter { + options := AcmeDomainValidationValidatedWaiterOptions{} + options.MinDelay = 5 * time.Second + options.MaxDelay = 300 * time.Second + options.Retryable = acmeDomainValidationValidatedStateRetryable + + for _, fn := range optFns { + fn(&options) + } + return &AcmeDomainValidationValidatedWaiter{ + client: client, + options: options, + } +} + +// Wait calls the waiter function for AcmeDomainValidationValidated waiter. The +// maxWaitDur is the maximum wait duration the waiter will wait. The maxWaitDur is +// required and must be greater than zero. +func (w *AcmeDomainValidationValidatedWaiter) Wait(ctx context.Context, params *DescribeAcmeDomainValidationInput, maxWaitDur time.Duration, optFns ...func(*AcmeDomainValidationValidatedWaiterOptions)) error { + _, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...) + return err +} + +// WaitForOutput calls the waiter function for AcmeDomainValidationValidated +// 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 *AcmeDomainValidationValidatedWaiter) WaitForOutput(ctx context.Context, params *DescribeAcmeDomainValidationInput, maxWaitDur time.Duration, optFns ...func(*AcmeDomainValidationValidatedWaiterOptions)) (*DescribeAcmeDomainValidationOutput, 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 = 300 * 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.DescribeAcmeDomainValidation(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 AcmeDomainValidationValidated waiter") +} + +func acmeDomainValidationValidatedStateRetryable(ctx context.Context, input *DescribeAcmeDomainValidationInput, output *DescribeAcmeDomainValidationOutput, err error) (bool, error) { + + if err == nil { + v1 := output.AcmeDomainValidation + var v2 types.AcmeDomainValidationStatus + if v1 != nil { + v3 := v1.Status + v2 = v3 + } + expectedValue := "VALID" + var pathValue string + pathValue = string(v2) + if pathValue == expectedValue { + return false, nil + } + } + + if err == nil { + v1 := output.AcmeDomainValidation + var v2 types.AcmeDomainValidationStatus + if v1 != nil { + v3 := v1.Status + v2 = v3 + } + expectedValue := "INVALID" + var pathValue string + pathValue = string(v2) + if pathValue == expectedValue { + return false, fmt.Errorf("waiter state transitioned to Failure") + } + } + + if err == nil { + v1 := output.AcmeDomainValidation + var v2 types.AcmeDomainValidationStatus + if v1 != nil { + v3 := v1.Status + v2 = v3 + } + expectedValue := "VALIDATING" + var pathValue string + pathValue = string(v2) + if pathValue == expectedValue { + return true, nil + } + } + + if err != nil { + return false, err + } + return true, nil +} + +// AcmeDomainValidationDeletedWaiterOptions are waiter options for +// AcmeDomainValidationDeletedWaiter +type AcmeDomainValidationDeletedWaiterOptions 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, + // AcmeDomainValidationDeletedWaiter will use default minimum delay of 5 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, AcmeDomainValidationDeletedWaiter will use default max delay of 300 + // 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, *DescribeAcmeDomainValidationInput, *DescribeAcmeDomainValidationOutput, error) (bool, error) +} + +// AcmeDomainValidationDeletedWaiter defines the waiters for +// AcmeDomainValidationDeleted +type AcmeDomainValidationDeletedWaiter struct { + client DescribeAcmeDomainValidationAPIClient + + options AcmeDomainValidationDeletedWaiterOptions +} + +// NewAcmeDomainValidationDeletedWaiter constructs a +// AcmeDomainValidationDeletedWaiter. +func NewAcmeDomainValidationDeletedWaiter(client DescribeAcmeDomainValidationAPIClient, optFns ...func(*AcmeDomainValidationDeletedWaiterOptions)) *AcmeDomainValidationDeletedWaiter { + options := AcmeDomainValidationDeletedWaiterOptions{} + options.MinDelay = 5 * time.Second + options.MaxDelay = 300 * time.Second + options.Retryable = acmeDomainValidationDeletedStateRetryable + + for _, fn := range optFns { + fn(&options) + } + return &AcmeDomainValidationDeletedWaiter{ + client: client, + options: options, + } +} + +// Wait calls the waiter function for AcmeDomainValidationDeleted waiter. The +// maxWaitDur is the maximum wait duration the waiter will wait. The maxWaitDur is +// required and must be greater than zero. +func (w *AcmeDomainValidationDeletedWaiter) Wait(ctx context.Context, params *DescribeAcmeDomainValidationInput, maxWaitDur time.Duration, optFns ...func(*AcmeDomainValidationDeletedWaiterOptions)) error { + _, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...) + return err +} + +// WaitForOutput calls the waiter function for AcmeDomainValidationDeleted 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 *AcmeDomainValidationDeletedWaiter) WaitForOutput(ctx context.Context, params *DescribeAcmeDomainValidationInput, maxWaitDur time.Duration, optFns ...func(*AcmeDomainValidationDeletedWaiterOptions)) (*DescribeAcmeDomainValidationOutput, 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 = 300 * 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.DescribeAcmeDomainValidation(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 AcmeDomainValidationDeleted waiter") +} + +func acmeDomainValidationDeletedStateRetryable(ctx context.Context, input *DescribeAcmeDomainValidationInput, output *DescribeAcmeDomainValidationOutput, err error) (bool, error) { + + if err != nil { + var errorType *types.ResourceNotFoundException + if errors.As(err, &errorType) { + return false, nil + } + } + + if err == nil { + v1 := output.AcmeDomainValidation + var v2 types.AcmeDomainValidationStatus + if v1 != nil { + v3 := v1.Status + v2 = v3 + } + expectedValue := "DELETING" + var pathValue string + pathValue = string(v2) + if pathValue == expectedValue { + return true, nil + } + } + + if err != nil { + return false, err + } + return true, nil +} + +// DescribeAcmeDomainValidationAPIClient is a client that implements the +// DescribeAcmeDomainValidation operation. +type DescribeAcmeDomainValidationAPIClient interface { + DescribeAcmeDomainValidation(context.Context, *DescribeAcmeDomainValidationInput, ...func(*Options)) (*DescribeAcmeDomainValidationOutput, error) +} + +var _ DescribeAcmeDomainValidationAPIClient = (*Client)(nil) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeAcmeEndpoint.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeAcmeEndpoint.go new file mode 100644 index 000000000..39b6542e1 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeAcmeEndpoint.go @@ -0,0 +1,542 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" + smithytime "github.com/aws/smithy-go/time" + smithywaiter "github.com/aws/smithy-go/waiter" + "time" +) + +// Returns detailed metadata about the specified ACME endpoint, including its +// status, URL, authorization behavior, and certificate authority configuration. +func (c *Client) DescribeAcmeEndpoint(ctx context.Context, params *DescribeAcmeEndpointInput, optFns ...func(*Options)) (*DescribeAcmeEndpointOutput, error) { + if params == nil { + params = &DescribeAcmeEndpointInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeAcmeEndpoint", params, optFns, c.addOperationDescribeAcmeEndpointMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeAcmeEndpointOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeAcmeEndpointInput struct { + + // The Amazon Resource Name (ARN) of the ACME endpoint. + // + // This member is required. + AcmeEndpointArn *string + + noSmithyDocumentSerde +} + +func (v *DescribeAcmeEndpointInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeAcmeEndpointRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeAcmeEndpointInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.DescribeAcmeEndpointRequest_AcmeEndpointArn, *v.AcmeEndpointArn) + } +} +func (in *DescribeAcmeEndpointInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type DescribeAcmeEndpointOutput struct { + + // The ACME endpoint details. + AcmeEndpoint *types.AcmeEndpoint + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *DescribeAcmeEndpointOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeAcmeEndpointResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeAcmeEndpointOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpoint != nil { + s.WriteStruct(schemas.DescribeAcmeEndpointResponse_AcmeEndpoint) + v.AcmeEndpoint.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *DescribeAcmeEndpointOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DescribeAcmeEndpointResponse, func(s *smithy.Schema) error { + switch s { + case schemas.DescribeAcmeEndpointResponse_AcmeEndpoint: + v.AcmeEndpoint = &types.AcmeEndpoint{} + return v.AcmeEndpoint.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationDescribeAcmeEndpointMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeAcmeEndpoint, schemas.DescribeAcmeEndpointRequest, schemas.DescribeAcmeEndpointResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeAcmeEndpoint, schemas.DescribeAcmeEndpointRequest, schemas.DescribeAcmeEndpointResponse), output: &DescribeAcmeEndpointOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDescribeAcmeEndpointValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// AcmeEndpointActiveWaiterOptions are waiter options for AcmeEndpointActiveWaiter +type AcmeEndpointActiveWaiterOptions 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, + // AcmeEndpointActiveWaiter will use default minimum delay of 5 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, AcmeEndpointActiveWaiter will use default max delay of 300 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, *DescribeAcmeEndpointInput, *DescribeAcmeEndpointOutput, error) (bool, error) +} + +// AcmeEndpointActiveWaiter defines the waiters for AcmeEndpointActive +type AcmeEndpointActiveWaiter struct { + client DescribeAcmeEndpointAPIClient + + options AcmeEndpointActiveWaiterOptions +} + +// NewAcmeEndpointActiveWaiter constructs a AcmeEndpointActiveWaiter. +func NewAcmeEndpointActiveWaiter(client DescribeAcmeEndpointAPIClient, optFns ...func(*AcmeEndpointActiveWaiterOptions)) *AcmeEndpointActiveWaiter { + options := AcmeEndpointActiveWaiterOptions{} + options.MinDelay = 5 * time.Second + options.MaxDelay = 300 * time.Second + options.Retryable = acmeEndpointActiveStateRetryable + + for _, fn := range optFns { + fn(&options) + } + return &AcmeEndpointActiveWaiter{ + client: client, + options: options, + } +} + +// Wait calls the waiter function for AcmeEndpointActive waiter. The maxWaitDur is +// the maximum wait duration the waiter will wait. The maxWaitDur is required and +// must be greater than zero. +func (w *AcmeEndpointActiveWaiter) Wait(ctx context.Context, params *DescribeAcmeEndpointInput, maxWaitDur time.Duration, optFns ...func(*AcmeEndpointActiveWaiterOptions)) error { + _, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...) + return err +} + +// WaitForOutput calls the waiter function for AcmeEndpointActive 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 *AcmeEndpointActiveWaiter) WaitForOutput(ctx context.Context, params *DescribeAcmeEndpointInput, maxWaitDur time.Duration, optFns ...func(*AcmeEndpointActiveWaiterOptions)) (*DescribeAcmeEndpointOutput, 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 = 300 * 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.DescribeAcmeEndpoint(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 AcmeEndpointActive waiter") +} + +func acmeEndpointActiveStateRetryable(ctx context.Context, input *DescribeAcmeEndpointInput, output *DescribeAcmeEndpointOutput, err error) (bool, error) { + + if err == nil { + v1 := output.AcmeEndpoint + var v2 types.AcmeEndpointStatus + if v1 != nil { + v3 := v1.Status + v2 = v3 + } + expectedValue := "ACTIVE" + var pathValue string + pathValue = string(v2) + if pathValue == expectedValue { + return false, nil + } + } + + if err == nil { + v1 := output.AcmeEndpoint + var v2 types.AcmeEndpointStatus + if v1 != nil { + v3 := v1.Status + v2 = v3 + } + expectedValue := "FAILED" + var pathValue string + pathValue = string(v2) + if pathValue == expectedValue { + return false, fmt.Errorf("waiter state transitioned to Failure") + } + } + + if err == nil { + v1 := output.AcmeEndpoint + var v2 types.AcmeEndpointStatus + if v1 != nil { + v3 := v1.Status + v2 = v3 + } + expectedValue := "CREATING" + var pathValue string + pathValue = string(v2) + if pathValue == expectedValue { + return true, nil + } + } + + if err != nil { + return false, err + } + return true, nil +} + +// AcmeEndpointDeletedWaiterOptions are waiter options for +// AcmeEndpointDeletedWaiter +type AcmeEndpointDeletedWaiterOptions 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, + // AcmeEndpointDeletedWaiter will use default minimum delay of 5 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, AcmeEndpointDeletedWaiter will use default max delay of 300 + // 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, *DescribeAcmeEndpointInput, *DescribeAcmeEndpointOutput, error) (bool, error) +} + +// AcmeEndpointDeletedWaiter defines the waiters for AcmeEndpointDeleted +type AcmeEndpointDeletedWaiter struct { + client DescribeAcmeEndpointAPIClient + + options AcmeEndpointDeletedWaiterOptions +} + +// NewAcmeEndpointDeletedWaiter constructs a AcmeEndpointDeletedWaiter. +func NewAcmeEndpointDeletedWaiter(client DescribeAcmeEndpointAPIClient, optFns ...func(*AcmeEndpointDeletedWaiterOptions)) *AcmeEndpointDeletedWaiter { + options := AcmeEndpointDeletedWaiterOptions{} + options.MinDelay = 5 * time.Second + options.MaxDelay = 300 * time.Second + options.Retryable = acmeEndpointDeletedStateRetryable + + for _, fn := range optFns { + fn(&options) + } + return &AcmeEndpointDeletedWaiter{ + client: client, + options: options, + } +} + +// Wait calls the waiter function for AcmeEndpointDeleted waiter. The maxWaitDur +// is the maximum wait duration the waiter will wait. The maxWaitDur is required +// and must be greater than zero. +func (w *AcmeEndpointDeletedWaiter) Wait(ctx context.Context, params *DescribeAcmeEndpointInput, maxWaitDur time.Duration, optFns ...func(*AcmeEndpointDeletedWaiterOptions)) error { + _, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...) + return err +} + +// WaitForOutput calls the waiter function for AcmeEndpointDeleted 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 *AcmeEndpointDeletedWaiter) WaitForOutput(ctx context.Context, params *DescribeAcmeEndpointInput, maxWaitDur time.Duration, optFns ...func(*AcmeEndpointDeletedWaiterOptions)) (*DescribeAcmeEndpointOutput, 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 = 300 * 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.DescribeAcmeEndpoint(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 AcmeEndpointDeleted waiter") +} + +func acmeEndpointDeletedStateRetryable(ctx context.Context, input *DescribeAcmeEndpointInput, output *DescribeAcmeEndpointOutput, err error) (bool, error) { + + if err != nil { + var errorType *types.ResourceNotFoundException + if errors.As(err, &errorType) { + return false, nil + } + } + + if err == nil { + v1 := output.AcmeEndpoint + var v2 types.AcmeEndpointStatus + if v1 != nil { + v3 := v1.Status + v2 = v3 + } + expectedValue := "DELETING" + var pathValue string + pathValue = string(v2) + if pathValue == expectedValue { + return true, nil + } + } + + if err != nil { + return false, err + } + return true, nil +} + +// DescribeAcmeEndpointAPIClient is a client that implements the +// DescribeAcmeEndpoint operation. +type DescribeAcmeEndpointAPIClient interface { + DescribeAcmeEndpoint(context.Context, *DescribeAcmeEndpointInput, ...func(*Options)) (*DescribeAcmeEndpointOutput, error) +} + +var _ DescribeAcmeEndpointAPIClient = (*Client)(nil) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeAcmeExternalAccountBinding.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeAcmeExternalAccountBinding.go new file mode 100644 index 000000000..b546d6f0b --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeAcmeExternalAccountBinding.go @@ -0,0 +1,130 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Returns detailed metadata about the specified external account binding, +// including the associated IAM role, expiration time, and usage history. +func (c *Client) DescribeAcmeExternalAccountBinding(ctx context.Context, params *DescribeAcmeExternalAccountBindingInput, optFns ...func(*Options)) (*DescribeAcmeExternalAccountBindingOutput, error) { + if params == nil { + params = &DescribeAcmeExternalAccountBindingInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeAcmeExternalAccountBinding", params, optFns, c.addOperationDescribeAcmeExternalAccountBindingMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeAcmeExternalAccountBindingOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeAcmeExternalAccountBindingInput struct { + + // The Amazon Resource Name (ARN) of the ACME external account binding. + // + // This member is required. + AcmeExternalAccountBindingArn *string + + noSmithyDocumentSerde +} + +func (v *DescribeAcmeExternalAccountBindingInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeAcmeExternalAccountBindingRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeAcmeExternalAccountBindingInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeExternalAccountBindingArn != nil { + s.WriteString(schemas.DescribeAcmeExternalAccountBindingRequest_AcmeExternalAccountBindingArn, *v.AcmeExternalAccountBindingArn) + } +} +func (in *DescribeAcmeExternalAccountBindingInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type DescribeAcmeExternalAccountBindingOutput struct { + + // The external account binding details. + ExternalAccountBinding *types.AcmeExternalAccountBinding + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *DescribeAcmeExternalAccountBindingOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeAcmeExternalAccountBindingResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeAcmeExternalAccountBindingOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.ExternalAccountBinding != nil { + s.WriteStruct(schemas.DescribeAcmeExternalAccountBindingResponse_ExternalAccountBinding) + v.ExternalAccountBinding.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *DescribeAcmeExternalAccountBindingOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DescribeAcmeExternalAccountBindingResponse, func(s *smithy.Schema) error { + switch s { + case schemas.DescribeAcmeExternalAccountBindingResponse_ExternalAccountBinding: + v.ExternalAccountBinding = &types.AcmeExternalAccountBinding{} + return v.ExternalAccountBinding.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationDescribeAcmeExternalAccountBindingMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeAcmeExternalAccountBinding, schemas.DescribeAcmeExternalAccountBindingRequest, schemas.DescribeAcmeExternalAccountBindingResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeAcmeExternalAccountBinding, schemas.DescribeAcmeExternalAccountBindingRequest, schemas.DescribeAcmeExternalAccountBindingResponse), output: &DescribeAcmeExternalAccountBindingOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDescribeAcmeExternalAccountBindingValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeCertificate.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeCertificate.go index ba3f33ad2..1b193148f 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeCertificate.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_DescribeCertificate.go @@ -6,11 +6,12 @@ import ( "context" "errors" "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" smithytime "github.com/aws/smithy-go/time" - smithyhttp "github.com/aws/smithy-go/transport/http" smithywaiter "github.com/aws/smithy-go/waiter" "time" ) @@ -52,6 +53,22 @@ type DescribeCertificateInput struct { noSmithyDocumentSerde } +func (v *DescribeCertificateInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeCertificateRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeCertificateInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.DescribeCertificateRequest_CertificateArn, *v.CertificateArn) + } +} +func (in *DescribeCertificateInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type DescribeCertificateOutput struct { // Metadata about an ACM certificate. @@ -63,65 +80,44 @@ type DescribeCertificateOutput struct { noSmithyDocumentSerde } -func (c *Client) addOperationDescribeCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeCertificate{}, middleware.After) - if err != nil { - return err - } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeCertificate{}, middleware.After) - if err != nil { - return err - } - if err := addProtocolFinalizerMiddlewares(stack, options, "DescribeCertificate"); err != nil { - return fmt.Errorf("add protocol finalizers: %v", err) - } +func (v *DescribeCertificateOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeCertificateResponse) + v.SerializeMembers(s) + s.CloseStruct() +} - if err = addlegacyEndpointContextSetter(stack, options); err != nil { - return err - } - if err = addSetLoggerMiddleware(stack, options); err != nil { - return err +func (v *DescribeCertificateOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.Certificate != nil { + s.WriteStruct(schemas.DescribeCertificateResponse_Certificate) + v.Certificate.SerializeMembers(s) + s.CloseStruct() } - if err = addClientRequestID(stack); err != nil { +} +func (v *DescribeCertificateOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DescribeCertificateResponse, func(s *smithy.Schema) error { + switch s { + case schemas.DescribeCertificateResponse_Certificate: + v.Certificate = &types.CertificateDetail{} + return v.Certificate.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationDescribeCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeCertificate, schemas.DescribeCertificateRequest, schemas.DescribeCertificateResponse)}, middleware.After); err != nil { return err } - if err = addComputeContentLength(stack); err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeCertificate, schemas.DescribeCertificateRequest, schemas.DescribeCertificateResponse), output: &DescribeCertificateOutput{}}, middleware.After); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -130,12 +126,6 @@ func (c *Client) addOperationDescribeCertificateMiddlewares(stack *middleware.St if err = addOpDescribeCertificateValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeCertificate(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -148,12 +138,6 @@ func (c *Client) addOperationDescribeCertificateMiddlewares(stack *middleware.St 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 } @@ -408,11 +392,3 @@ type DescribeCertificateAPIClient interface { } var _ DescribeCertificateAPIClient = (*Client)(nil) - -func newServiceMetadataMiddleware_opDescribeCertificate(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "DescribeCertificate", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ExportCertificate.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ExportCertificate.go index 32bd7ee03..6a46388f0 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ExportCertificate.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ExportCertificate.go @@ -4,10 +4,10 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Exports a private certificate issued by a private certificate authority (CA) or @@ -65,6 +65,25 @@ type ExportCertificateInput struct { noSmithyDocumentSerde } +func (v *ExportCertificateInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ExportCertificateRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ExportCertificateInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.ExportCertificateRequest_CertificateArn, *v.CertificateArn) + } + if v.Passphrase != nil { + s.WriteBlob(schemas.ExportCertificateRequest_Passphrase, v.Passphrase) + } +} +func (in *ExportCertificateInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type ExportCertificateOutput struct { // The base64 PEM-encoded certificate. @@ -84,65 +103,54 @@ type ExportCertificateOutput struct { noSmithyDocumentSerde } -func (c *Client) addOperationExportCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpExportCertificate{}, middleware.After) - if err != nil { - return err - } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpExportCertificate{}, middleware.After) - if err != nil { - return err - } - if err := addProtocolFinalizerMiddlewares(stack, options, "ExportCertificate"); err != nil { - return fmt.Errorf("add protocol finalizers: %v", err) - } +func (v *ExportCertificateOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ExportCertificateResponse) + v.SerializeMembers(s) + s.CloseStruct() +} - if err = addlegacyEndpointContextSetter(stack, options); err != nil { - return err +func (v *ExportCertificateOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.Certificate != nil { + s.WriteString(schemas.ExportCertificateResponse_Certificate, *v.Certificate) } - if err = addSetLoggerMiddleware(stack, options); err != nil { - return err + if v.CertificateChain != nil { + s.WriteString(schemas.ExportCertificateResponse_CertificateChain, *v.CertificateChain) } - if err = addClientRequestID(stack); err != nil { + if v.PrivateKey != nil { + s.WriteString(schemas.ExportCertificateResponse_PrivateKey, *v.PrivateKey) + } +} +func (v *ExportCertificateOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ExportCertificateResponse, func(s *smithy.Schema) error { + switch s { + case schemas.ExportCertificateResponse_Certificate: + v.Certificate = new(string) + return d.ReadString(schemas.ExportCertificateResponse_Certificate, v.Certificate) + case schemas.ExportCertificateResponse_CertificateChain: + v.CertificateChain = new(string) + return d.ReadString(schemas.ExportCertificateResponse_CertificateChain, v.CertificateChain) + case schemas.ExportCertificateResponse_PrivateKey: + v.PrivateKey = new(string) + return d.ReadString(schemas.ExportCertificateResponse_PrivateKey, v.PrivateKey) + } + return nil + }) +} +func (c *Client) addOperationExportCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ExportCertificate, schemas.ExportCertificateRequest, schemas.ExportCertificateResponse)}, middleware.After); err != nil { return err } - if err = addComputeContentLength(stack); err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ExportCertificate, schemas.ExportCertificateRequest, schemas.ExportCertificateResponse), output: &ExportCertificateOutput{}}, middleware.After); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -151,12 +159,6 @@ func (c *Client) addOperationExportCertificateMiddlewares(stack *middleware.Stac if err = addOpExportCertificateValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opExportCertificate(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -169,22 +171,8 @@ func (c *Client) addOperationExportCertificateMiddlewares(stack *middleware.Stac 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 } - -func newServiceMetadataMiddleware_opExportCertificate(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "ExportCertificate", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_GetAccountConfiguration.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_GetAccountConfiguration.go index d71a7a024..7d00c881d 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_GetAccountConfiguration.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_GetAccountConfiguration.go @@ -4,11 +4,11 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Returns the account configuration options associated with an Amazon Web @@ -32,6 +32,26 @@ type GetAccountConfigurationInput struct { noSmithyDocumentSerde } +func (v *GetAccountConfigurationInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *GetAccountConfigurationInput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *GetAccountConfigurationInput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} +func (in *GetAccountConfigurationInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type GetAccountConfigurationOutput struct { // Expiration events configuration options associated with the Amazon Web Services @@ -44,76 +64,49 @@ type GetAccountConfigurationOutput struct { noSmithyDocumentSerde } -func (c *Client) addOperationGetAccountConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetAccountConfiguration{}, middleware.After) - if err != nil { - return err - } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetAccountConfiguration{}, middleware.After) - if err != nil { - return err - } - if err := addProtocolFinalizerMiddlewares(stack, options, "GetAccountConfiguration"); err != nil { - return fmt.Errorf("add protocol finalizers: %v", err) - } +func (v *GetAccountConfigurationOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GetAccountConfigurationResponse) + v.SerializeMembers(s) + s.CloseStruct() +} - if err = addlegacyEndpointContextSetter(stack, options); err != nil { - return err +func (v *GetAccountConfigurationOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.ExpiryEvents != nil { + s.WriteStruct(schemas.GetAccountConfigurationResponse_ExpiryEvents) + v.ExpiryEvents.SerializeMembers(s) + s.CloseStruct() } - if err = addSetLoggerMiddleware(stack, options); err != nil { - return err - } - if err = addClientRequestID(stack); err != nil { +} +func (v *GetAccountConfigurationOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.GetAccountConfigurationResponse, func(s *smithy.Schema) error { + switch s { + case schemas.GetAccountConfigurationResponse_ExpiryEvents: + v.ExpiryEvents = &types.ExpiryEventsConfiguration{} + return v.ExpiryEvents.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationGetAccountConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetAccountConfiguration, nil, schemas.GetAccountConfigurationResponse)}, middleware.After); err != nil { return err } - if err = addComputeContentLength(stack); err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetAccountConfiguration, nil, schemas.GetAccountConfigurationResponse), output: &GetAccountConfigurationOutput{}}, middleware.After); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetAccountConfiguration(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -126,22 +119,8 @@ func (c *Client) addOperationGetAccountConfigurationMiddlewares(stack *middlewar 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 } - -func newServiceMetadataMiddleware_opGetAccountConfiguration(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "GetAccountConfiguration", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_GetAcmeExternalAccountBindingCredentials.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_GetAcmeExternalAccountBindingCredentials.go new file mode 100644 index 000000000..9251bb571 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_GetAcmeExternalAccountBindingCredentials.go @@ -0,0 +1,137 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Retrieves the key ID and MAC key credentials for an external account binding. +// These credentials are used by ACME clients during account registration to bind +// to the endpoint. +func (c *Client) GetAcmeExternalAccountBindingCredentials(ctx context.Context, params *GetAcmeExternalAccountBindingCredentialsInput, optFns ...func(*Options)) (*GetAcmeExternalAccountBindingCredentialsOutput, error) { + if params == nil { + params = &GetAcmeExternalAccountBindingCredentialsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetAcmeExternalAccountBindingCredentials", params, optFns, c.addOperationGetAcmeExternalAccountBindingCredentialsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetAcmeExternalAccountBindingCredentialsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetAcmeExternalAccountBindingCredentialsInput struct { + + // The Amazon Resource Name (ARN) of the ACME external account binding. + // + // This member is required. + AcmeExternalAccountBindingArn *string + + noSmithyDocumentSerde +} + +func (v *GetAcmeExternalAccountBindingCredentialsInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GetAcmeExternalAccountBindingCredentialsRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *GetAcmeExternalAccountBindingCredentialsInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeExternalAccountBindingArn != nil { + s.WriteString(schemas.GetAcmeExternalAccountBindingCredentialsRequest_AcmeExternalAccountBindingArn, *v.AcmeExternalAccountBindingArn) + } +} +func (in *GetAcmeExternalAccountBindingCredentialsInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type GetAcmeExternalAccountBindingCredentialsOutput struct { + + // The key identifier for the external account binding credentials. + KeyId *string + + // The MAC key for the external account binding credentials. + MacKey *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *GetAcmeExternalAccountBindingCredentialsOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GetAcmeExternalAccountBindingCredentialsResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *GetAcmeExternalAccountBindingCredentialsOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.KeyId != nil { + s.WriteString(schemas.GetAcmeExternalAccountBindingCredentialsResponse_KeyId, *v.KeyId) + } + if v.MacKey != nil { + s.WriteString(schemas.GetAcmeExternalAccountBindingCredentialsResponse_MacKey, *v.MacKey) + } +} +func (v *GetAcmeExternalAccountBindingCredentialsOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.GetAcmeExternalAccountBindingCredentialsResponse, func(s *smithy.Schema) error { + switch s { + case schemas.GetAcmeExternalAccountBindingCredentialsResponse_KeyId: + v.KeyId = new(string) + return d.ReadString(schemas.GetAcmeExternalAccountBindingCredentialsResponse_KeyId, v.KeyId) + case schemas.GetAcmeExternalAccountBindingCredentialsResponse_MacKey: + v.MacKey = new(string) + return d.ReadString(schemas.GetAcmeExternalAccountBindingCredentialsResponse_MacKey, v.MacKey) + } + return nil + }) +} +func (c *Client) addOperationGetAcmeExternalAccountBindingCredentialsMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetAcmeExternalAccountBindingCredentials, schemas.GetAcmeExternalAccountBindingCredentialsRequest, schemas.GetAcmeExternalAccountBindingCredentialsResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetAcmeExternalAccountBindingCredentials, schemas.GetAcmeExternalAccountBindingCredentialsRequest, schemas.GetAcmeExternalAccountBindingCredentialsResponse), output: &GetAcmeExternalAccountBindingCredentialsOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpGetAcmeExternalAccountBindingCredentialsValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_GetCertificate.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_GetCertificate.go index 99d9beefa..4a13eca6c 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_GetCertificate.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_GetCertificate.go @@ -4,10 +4,10 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Retrieves a certificate and its certificate chain. The certificate may be @@ -49,6 +49,22 @@ type GetCertificateInput struct { noSmithyDocumentSerde } +func (v *GetCertificateInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GetCertificateRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *GetCertificateInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.GetCertificateRequest_CertificateArn, *v.CertificateArn) + } +} +func (in *GetCertificateInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type GetCertificateOutput struct { // The ACM-issued certificate corresponding to the ARN specified as input. @@ -65,65 +81,48 @@ type GetCertificateOutput struct { noSmithyDocumentSerde } -func (c *Client) addOperationGetCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetCertificate{}, middleware.After) - if err != nil { - return err - } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetCertificate{}, middleware.After) - if err != nil { - return err - } - if err := addProtocolFinalizerMiddlewares(stack, options, "GetCertificate"); err != nil { - return fmt.Errorf("add protocol finalizers: %v", err) - } +func (v *GetCertificateOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GetCertificateResponse) + v.SerializeMembers(s) + s.CloseStruct() +} - if err = addlegacyEndpointContextSetter(stack, options); err != nil { - return err +func (v *GetCertificateOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.Certificate != nil { + s.WriteString(schemas.GetCertificateResponse_Certificate, *v.Certificate) } - if err = addSetLoggerMiddleware(stack, options); err != nil { - return err + if v.CertificateChain != nil { + s.WriteString(schemas.GetCertificateResponse_CertificateChain, *v.CertificateChain) } - if err = addClientRequestID(stack); err != nil { +} +func (v *GetCertificateOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.GetCertificateResponse, func(s *smithy.Schema) error { + switch s { + case schemas.GetCertificateResponse_Certificate: + v.Certificate = new(string) + return d.ReadString(schemas.GetCertificateResponse_Certificate, v.Certificate) + case schemas.GetCertificateResponse_CertificateChain: + v.CertificateChain = new(string) + return d.ReadString(schemas.GetCertificateResponse_CertificateChain, v.CertificateChain) + } + return nil + }) +} +func (c *Client) addOperationGetCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetCertificate, schemas.GetCertificateRequest, schemas.GetCertificateResponse)}, middleware.After); err != nil { return err } - if err = addComputeContentLength(stack); err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetCertificate, schemas.GetCertificateRequest, schemas.GetCertificateResponse), output: &GetCertificateOutput{}}, middleware.After); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -132,12 +131,6 @@ func (c *Client) addOperationGetCertificateMiddlewares(stack *middleware.Stack, if err = addOpGetCertificateValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetCertificate(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -150,22 +143,8 @@ func (c *Client) addOperationGetCertificateMiddlewares(stack *middleware.Stack, 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 } - -func newServiceMetadataMiddleware_opGetCertificate(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "GetCertificate", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ImportCertificate.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ImportCertificate.go index 6d81d088d..35f507635 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ImportCertificate.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ImportCertificate.go @@ -4,11 +4,11 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Imports a certificate into Certificate Manager (ACM) to use with services that @@ -106,6 +106,32 @@ type ImportCertificateInput struct { noSmithyDocumentSerde } +func (v *ImportCertificateInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ImportCertificateRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ImportCertificateInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.Certificate != nil { + s.WriteBlob(schemas.ImportCertificateRequest_Certificate, v.Certificate) + } + if v.CertificateArn != nil { + s.WriteString(schemas.ImportCertificateRequest_CertificateArn, *v.CertificateArn) + } + if v.CertificateChain != nil { + s.WriteBlob(schemas.ImportCertificateRequest_CertificateChain, v.CertificateChain) + } + if v.PrivateKey != nil { + s.WriteBlob(schemas.ImportCertificateRequest_PrivateKey, v.PrivateKey) + } + serializeTagList(s, schemas.ImportCertificateRequest_Tags, v.Tags) +} +func (in *ImportCertificateInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type ImportCertificateOutput struct { // The [Amazon Resource Name (ARN)] of the imported certificate. @@ -119,65 +145,42 @@ type ImportCertificateOutput struct { noSmithyDocumentSerde } -func (c *Client) addOperationImportCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpImportCertificate{}, middleware.After) - if err != nil { - return err - } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpImportCertificate{}, middleware.After) - if err != nil { - return err - } - if err := addProtocolFinalizerMiddlewares(stack, options, "ImportCertificate"); err != nil { - return fmt.Errorf("add protocol finalizers: %v", err) - } +func (v *ImportCertificateOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ImportCertificateResponse) + v.SerializeMembers(s) + s.CloseStruct() +} - if err = addlegacyEndpointContextSetter(stack, options); err != nil { - return err - } - if err = addSetLoggerMiddleware(stack, options); err != nil { - return err +func (v *ImportCertificateOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.ImportCertificateResponse_CertificateArn, *v.CertificateArn) } - if err = addClientRequestID(stack); err != nil { +} +func (v *ImportCertificateOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ImportCertificateResponse, func(s *smithy.Schema) error { + switch s { + case schemas.ImportCertificateResponse_CertificateArn: + v.CertificateArn = new(string) + return d.ReadString(schemas.ImportCertificateResponse_CertificateArn, v.CertificateArn) + } + return nil + }) +} +func (c *Client) addOperationImportCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ImportCertificate, schemas.ImportCertificateRequest, schemas.ImportCertificateResponse)}, middleware.After); err != nil { return err } - if err = addComputeContentLength(stack); err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ImportCertificate, schemas.ImportCertificateRequest, schemas.ImportCertificateResponse), output: &ImportCertificateOutput{}}, middleware.After); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -186,12 +189,6 @@ func (c *Client) addOperationImportCertificateMiddlewares(stack *middleware.Stac if err = addOpImportCertificateValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opImportCertificate(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -204,22 +201,8 @@ func (c *Client) addOperationImportCertificateMiddlewares(stack *middleware.Stac 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 } - -func newServiceMetadataMiddleware_opImportCertificate(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "ImportCertificate", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListAcmeAccounts.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListAcmeAccounts.go new file mode 100644 index 000000000..a67a90aa2 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListAcmeAccounts.go @@ -0,0 +1,241 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Retrieves a list of ACME accounts registered with the specified ACME endpoint. +// ACME accounts are created when clients use external account binding credentials +// to register. +func (c *Client) ListAcmeAccounts(ctx context.Context, params *ListAcmeAccountsInput, optFns ...func(*Options)) (*ListAcmeAccountsOutput, error) { + if params == nil { + params = &ListAcmeAccountsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ListAcmeAccounts", params, optFns, c.addOperationListAcmeAccountsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ListAcmeAccountsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ListAcmeAccountsInput struct { + + // The Amazon Resource Name (ARN) of the ACME endpoint. + // + // This member is required. + AcmeEndpointArn *string + + // The maximum number of results to return. + MaxResults *int32 + + // A token for pagination. + NextToken *string + + noSmithyDocumentSerde +} + +func (v *ListAcmeAccountsInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListAcmeAccountsRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListAcmeAccountsInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.ListAcmeAccountsRequest_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.MaxResults != nil { + s.WriteInt32(schemas.ListAcmeAccountsRequest_MaxResults, *v.MaxResults) + } + if v.NextToken != nil { + s.WriteString(schemas.ListAcmeAccountsRequest_NextToken, *v.NextToken) + } +} +func (in *ListAcmeAccountsInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type ListAcmeAccountsOutput struct { + + // The list of ACME accounts. + AcmeAccounts []types.AcmeAccountSummary + + // A token for pagination. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *ListAcmeAccountsOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListAcmeAccountsResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListAcmeAccountsOutput) SerializeMembers(s smithy.ShapeSerializer) { + serializeAcmeAccountList(s, schemas.ListAcmeAccountsResponse_AcmeAccounts, v.AcmeAccounts) + if v.NextToken != nil { + s.WriteString(schemas.ListAcmeAccountsResponse_NextToken, *v.NextToken) + } +} +func (v *ListAcmeAccountsOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ListAcmeAccountsResponse, func(s *smithy.Schema) error { + switch s { + case schemas.ListAcmeAccountsResponse_AcmeAccounts: + return deserializeAcmeAccountList(d, schemas.ListAcmeAccountsResponse_AcmeAccounts, &v.AcmeAccounts) + case schemas.ListAcmeAccountsResponse_NextToken: + v.NextToken = new(string) + return d.ReadString(schemas.ListAcmeAccountsResponse_NextToken, v.NextToken) + } + return nil + }) +} +func (c *Client) addOperationListAcmeAccountsMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListAcmeAccounts, schemas.ListAcmeAccountsRequest, schemas.ListAcmeAccountsResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListAcmeAccounts, schemas.ListAcmeAccountsRequest, schemas.ListAcmeAccountsResponse), output: &ListAcmeAccountsOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpListAcmeAccountsValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// ListAcmeAccountsPaginatorOptions is the paginator options for ListAcmeAccounts +type ListAcmeAccountsPaginatorOptions struct { + // The maximum number of results to return. + 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 +} + +// ListAcmeAccountsPaginator is a paginator for ListAcmeAccounts +type ListAcmeAccountsPaginator struct { + options ListAcmeAccountsPaginatorOptions + client ListAcmeAccountsAPIClient + params *ListAcmeAccountsInput + nextToken *string + firstPage bool +} + +// NewListAcmeAccountsPaginator returns a new ListAcmeAccountsPaginator +func NewListAcmeAccountsPaginator(client ListAcmeAccountsAPIClient, params *ListAcmeAccountsInput, optFns ...func(*ListAcmeAccountsPaginatorOptions)) *ListAcmeAccountsPaginator { + if params == nil { + params = &ListAcmeAccountsInput{} + } + + options := ListAcmeAccountsPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &ListAcmeAccountsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *ListAcmeAccountsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next ListAcmeAccounts page. +func (p *ListAcmeAccountsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAcmeAccountsOutput, 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.ListAcmeAccounts(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 +} + +// ListAcmeAccountsAPIClient is a client that implements the ListAcmeAccounts +// operation. +type ListAcmeAccountsAPIClient interface { + ListAcmeAccounts(context.Context, *ListAcmeAccountsInput, ...func(*Options)) (*ListAcmeAccountsOutput, error) +} + +var _ ListAcmeAccountsAPIClient = (*Client)(nil) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListAcmeDomainValidations.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListAcmeDomainValidations.go new file mode 100644 index 000000000..4960d7fe3 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListAcmeDomainValidations.go @@ -0,0 +1,241 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Retrieves a list of domain validations for the specified ACME endpoint. +func (c *Client) ListAcmeDomainValidations(ctx context.Context, params *ListAcmeDomainValidationsInput, optFns ...func(*Options)) (*ListAcmeDomainValidationsOutput, error) { + if params == nil { + params = &ListAcmeDomainValidationsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ListAcmeDomainValidations", params, optFns, c.addOperationListAcmeDomainValidationsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ListAcmeDomainValidationsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ListAcmeDomainValidationsInput struct { + + // The Amazon Resource Name (ARN) of the ACME endpoint. + // + // This member is required. + AcmeEndpointArn *string + + // The maximum number of results to return. + MaxResults *int32 + + // A token for pagination. + NextToken *string + + noSmithyDocumentSerde +} + +func (v *ListAcmeDomainValidationsInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListAcmeDomainValidationsRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListAcmeDomainValidationsInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.ListAcmeDomainValidationsRequest_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.MaxResults != nil { + s.WriteInt32(schemas.ListAcmeDomainValidationsRequest_MaxResults, *v.MaxResults) + } + if v.NextToken != nil { + s.WriteString(schemas.ListAcmeDomainValidationsRequest_NextToken, *v.NextToken) + } +} +func (in *ListAcmeDomainValidationsInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type ListAcmeDomainValidationsOutput struct { + + // The list of domain validations. + AcmeDomainValidations []types.AcmeDomainValidationSummary + + // A token for pagination. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *ListAcmeDomainValidationsOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListAcmeDomainValidationsResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListAcmeDomainValidationsOutput) SerializeMembers(s smithy.ShapeSerializer) { + serializeAcmeDomainValidationList(s, schemas.ListAcmeDomainValidationsResponse_AcmeDomainValidations, v.AcmeDomainValidations) + if v.NextToken != nil { + s.WriteString(schemas.ListAcmeDomainValidationsResponse_NextToken, *v.NextToken) + } +} +func (v *ListAcmeDomainValidationsOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ListAcmeDomainValidationsResponse, func(s *smithy.Schema) error { + switch s { + case schemas.ListAcmeDomainValidationsResponse_AcmeDomainValidations: + return deserializeAcmeDomainValidationList(d, schemas.ListAcmeDomainValidationsResponse_AcmeDomainValidations, &v.AcmeDomainValidations) + case schemas.ListAcmeDomainValidationsResponse_NextToken: + v.NextToken = new(string) + return d.ReadString(schemas.ListAcmeDomainValidationsResponse_NextToken, v.NextToken) + } + return nil + }) +} +func (c *Client) addOperationListAcmeDomainValidationsMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListAcmeDomainValidations, schemas.ListAcmeDomainValidationsRequest, schemas.ListAcmeDomainValidationsResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListAcmeDomainValidations, schemas.ListAcmeDomainValidationsRequest, schemas.ListAcmeDomainValidationsResponse), output: &ListAcmeDomainValidationsOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpListAcmeDomainValidationsValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// ListAcmeDomainValidationsPaginatorOptions is the paginator options for +// ListAcmeDomainValidations +type ListAcmeDomainValidationsPaginatorOptions struct { + // The maximum number of results to return. + 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 +} + +// ListAcmeDomainValidationsPaginator is a paginator for ListAcmeDomainValidations +type ListAcmeDomainValidationsPaginator struct { + options ListAcmeDomainValidationsPaginatorOptions + client ListAcmeDomainValidationsAPIClient + params *ListAcmeDomainValidationsInput + nextToken *string + firstPage bool +} + +// NewListAcmeDomainValidationsPaginator returns a new +// ListAcmeDomainValidationsPaginator +func NewListAcmeDomainValidationsPaginator(client ListAcmeDomainValidationsAPIClient, params *ListAcmeDomainValidationsInput, optFns ...func(*ListAcmeDomainValidationsPaginatorOptions)) *ListAcmeDomainValidationsPaginator { + if params == nil { + params = &ListAcmeDomainValidationsInput{} + } + + options := ListAcmeDomainValidationsPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &ListAcmeDomainValidationsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *ListAcmeDomainValidationsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next ListAcmeDomainValidations page. +func (p *ListAcmeDomainValidationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAcmeDomainValidationsOutput, 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.ListAcmeDomainValidations(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 +} + +// ListAcmeDomainValidationsAPIClient is a client that implements the +// ListAcmeDomainValidations operation. +type ListAcmeDomainValidationsAPIClient interface { + ListAcmeDomainValidations(context.Context, *ListAcmeDomainValidationsInput, ...func(*Options)) (*ListAcmeDomainValidationsOutput, error) +} + +var _ ListAcmeDomainValidationsAPIClient = (*Client)(nil) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListAcmeEndpoints.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListAcmeEndpoints.go new file mode 100644 index 000000000..aaf964697 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListAcmeEndpoints.go @@ -0,0 +1,229 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Retrieves a list of ACME endpoints in your account. Use this operation to view +// all configured ACME endpoints and their current status. +func (c *Client) ListAcmeEndpoints(ctx context.Context, params *ListAcmeEndpointsInput, optFns ...func(*Options)) (*ListAcmeEndpointsOutput, error) { + if params == nil { + params = &ListAcmeEndpointsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ListAcmeEndpoints", params, optFns, c.addOperationListAcmeEndpointsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ListAcmeEndpointsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ListAcmeEndpointsInput struct { + + // The maximum number of results to return. + MaxResults *int32 + + // A token for pagination. + NextToken *string + + noSmithyDocumentSerde +} + +func (v *ListAcmeEndpointsInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListAcmeEndpointsRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListAcmeEndpointsInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.MaxResults != nil { + s.WriteInt32(schemas.ListAcmeEndpointsRequest_MaxResults, *v.MaxResults) + } + if v.NextToken != nil { + s.WriteString(schemas.ListAcmeEndpointsRequest_NextToken, *v.NextToken) + } +} +func (in *ListAcmeEndpointsInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type ListAcmeEndpointsOutput struct { + + // The list of ACME endpoints. + AcmeEndpoints []types.AcmeEndpointSummary + + // A token for pagination. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *ListAcmeEndpointsOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListAcmeEndpointsResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListAcmeEndpointsOutput) SerializeMembers(s smithy.ShapeSerializer) { + serializeAcmeEndpointList(s, schemas.ListAcmeEndpointsResponse_AcmeEndpoints, v.AcmeEndpoints) + if v.NextToken != nil { + s.WriteString(schemas.ListAcmeEndpointsResponse_NextToken, *v.NextToken) + } +} +func (v *ListAcmeEndpointsOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ListAcmeEndpointsResponse, func(s *smithy.Schema) error { + switch s { + case schemas.ListAcmeEndpointsResponse_AcmeEndpoints: + return deserializeAcmeEndpointList(d, schemas.ListAcmeEndpointsResponse_AcmeEndpoints, &v.AcmeEndpoints) + case schemas.ListAcmeEndpointsResponse_NextToken: + v.NextToken = new(string) + return d.ReadString(schemas.ListAcmeEndpointsResponse_NextToken, v.NextToken) + } + return nil + }) +} +func (c *Client) addOperationListAcmeEndpointsMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListAcmeEndpoints, schemas.ListAcmeEndpointsRequest, schemas.ListAcmeEndpointsResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListAcmeEndpoints, schemas.ListAcmeEndpointsRequest, schemas.ListAcmeEndpointsResponse), output: &ListAcmeEndpointsOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); 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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// ListAcmeEndpointsPaginatorOptions is the paginator options for ListAcmeEndpoints +type ListAcmeEndpointsPaginatorOptions struct { + // The maximum number of results to return. + 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 +} + +// ListAcmeEndpointsPaginator is a paginator for ListAcmeEndpoints +type ListAcmeEndpointsPaginator struct { + options ListAcmeEndpointsPaginatorOptions + client ListAcmeEndpointsAPIClient + params *ListAcmeEndpointsInput + nextToken *string + firstPage bool +} + +// NewListAcmeEndpointsPaginator returns a new ListAcmeEndpointsPaginator +func NewListAcmeEndpointsPaginator(client ListAcmeEndpointsAPIClient, params *ListAcmeEndpointsInput, optFns ...func(*ListAcmeEndpointsPaginatorOptions)) *ListAcmeEndpointsPaginator { + if params == nil { + params = &ListAcmeEndpointsInput{} + } + + options := ListAcmeEndpointsPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &ListAcmeEndpointsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *ListAcmeEndpointsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next ListAcmeEndpoints page. +func (p *ListAcmeEndpointsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAcmeEndpointsOutput, 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.ListAcmeEndpoints(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 +} + +// ListAcmeEndpointsAPIClient is a client that implements the ListAcmeEndpoints +// operation. +type ListAcmeEndpointsAPIClient interface { + ListAcmeEndpoints(context.Context, *ListAcmeEndpointsInput, ...func(*Options)) (*ListAcmeEndpointsOutput, error) +} + +var _ ListAcmeEndpointsAPIClient = (*Client)(nil) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListAcmeExternalAccountBindings.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListAcmeExternalAccountBindings.go new file mode 100644 index 000000000..2ceed49bd --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListAcmeExternalAccountBindings.go @@ -0,0 +1,242 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Retrieves a list of external account bindings for the specified ACME endpoint. +func (c *Client) ListAcmeExternalAccountBindings(ctx context.Context, params *ListAcmeExternalAccountBindingsInput, optFns ...func(*Options)) (*ListAcmeExternalAccountBindingsOutput, error) { + if params == nil { + params = &ListAcmeExternalAccountBindingsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ListAcmeExternalAccountBindings", params, optFns, c.addOperationListAcmeExternalAccountBindingsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ListAcmeExternalAccountBindingsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ListAcmeExternalAccountBindingsInput struct { + + // The Amazon Resource Name (ARN) of the ACME endpoint. + // + // This member is required. + AcmeEndpointArn *string + + // The maximum number of results to return. + MaxResults *int32 + + // A token for pagination. + NextToken *string + + noSmithyDocumentSerde +} + +func (v *ListAcmeExternalAccountBindingsInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListAcmeExternalAccountBindingsRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListAcmeExternalAccountBindingsInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.ListAcmeExternalAccountBindingsRequest_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.MaxResults != nil { + s.WriteInt32(schemas.ListAcmeExternalAccountBindingsRequest_MaxResults, *v.MaxResults) + } + if v.NextToken != nil { + s.WriteString(schemas.ListAcmeExternalAccountBindingsRequest_NextToken, *v.NextToken) + } +} +func (in *ListAcmeExternalAccountBindingsInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type ListAcmeExternalAccountBindingsOutput struct { + + // The list of external account bindings. + ExternalAccountBindings []types.AcmeExternalAccountBindingSummary + + // A token for pagination. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *ListAcmeExternalAccountBindingsOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListAcmeExternalAccountBindingsResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListAcmeExternalAccountBindingsOutput) SerializeMembers(s smithy.ShapeSerializer) { + serializeAcmeExternalAccountBindingList(s, schemas.ListAcmeExternalAccountBindingsResponse_ExternalAccountBindings, v.ExternalAccountBindings) + if v.NextToken != nil { + s.WriteString(schemas.ListAcmeExternalAccountBindingsResponse_NextToken, *v.NextToken) + } +} +func (v *ListAcmeExternalAccountBindingsOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ListAcmeExternalAccountBindingsResponse, func(s *smithy.Schema) error { + switch s { + case schemas.ListAcmeExternalAccountBindingsResponse_ExternalAccountBindings: + return deserializeAcmeExternalAccountBindingList(d, schemas.ListAcmeExternalAccountBindingsResponse_ExternalAccountBindings, &v.ExternalAccountBindings) + case schemas.ListAcmeExternalAccountBindingsResponse_NextToken: + v.NextToken = new(string) + return d.ReadString(schemas.ListAcmeExternalAccountBindingsResponse_NextToken, v.NextToken) + } + return nil + }) +} +func (c *Client) addOperationListAcmeExternalAccountBindingsMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListAcmeExternalAccountBindings, schemas.ListAcmeExternalAccountBindingsRequest, schemas.ListAcmeExternalAccountBindingsResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListAcmeExternalAccountBindings, schemas.ListAcmeExternalAccountBindingsRequest, schemas.ListAcmeExternalAccountBindingsResponse), output: &ListAcmeExternalAccountBindingsOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpListAcmeExternalAccountBindingsValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// ListAcmeExternalAccountBindingsPaginatorOptions is the paginator options for +// ListAcmeExternalAccountBindings +type ListAcmeExternalAccountBindingsPaginatorOptions struct { + // The maximum number of results to return. + 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 +} + +// ListAcmeExternalAccountBindingsPaginator is a paginator for +// ListAcmeExternalAccountBindings +type ListAcmeExternalAccountBindingsPaginator struct { + options ListAcmeExternalAccountBindingsPaginatorOptions + client ListAcmeExternalAccountBindingsAPIClient + params *ListAcmeExternalAccountBindingsInput + nextToken *string + firstPage bool +} + +// NewListAcmeExternalAccountBindingsPaginator returns a new +// ListAcmeExternalAccountBindingsPaginator +func NewListAcmeExternalAccountBindingsPaginator(client ListAcmeExternalAccountBindingsAPIClient, params *ListAcmeExternalAccountBindingsInput, optFns ...func(*ListAcmeExternalAccountBindingsPaginatorOptions)) *ListAcmeExternalAccountBindingsPaginator { + if params == nil { + params = &ListAcmeExternalAccountBindingsInput{} + } + + options := ListAcmeExternalAccountBindingsPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &ListAcmeExternalAccountBindingsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *ListAcmeExternalAccountBindingsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next ListAcmeExternalAccountBindings page. +func (p *ListAcmeExternalAccountBindingsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAcmeExternalAccountBindingsOutput, 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.ListAcmeExternalAccountBindings(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 +} + +// ListAcmeExternalAccountBindingsAPIClient is a client that implements the +// ListAcmeExternalAccountBindings operation. +type ListAcmeExternalAccountBindingsAPIClient interface { + ListAcmeExternalAccountBindings(context.Context, *ListAcmeExternalAccountBindingsInput, ...func(*Options)) (*ListAcmeExternalAccountBindingsOutput, error) +} + +var _ ListAcmeExternalAccountBindingsAPIClient = (*Client)(nil) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListCertificateDomainValidations.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListCertificateDomainValidations.go new file mode 100644 index 000000000..20cf7d32b --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListCertificateDomainValidations.go @@ -0,0 +1,254 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Returns per-domain validation summaries for an ACM certificate. Each summary +// includes the domain name, the active validation configuration, and the requested +// validation configuration when a validation method migration is in progress. You +// can use the results to monitor the progress of an email-to-DNS validation +// migration and to retrieve the CNAME records required for DNS validation. +func (c *Client) ListCertificateDomainValidations(ctx context.Context, params *ListCertificateDomainValidationsInput, optFns ...func(*Options)) (*ListCertificateDomainValidationsOutput, error) { + if params == nil { + params = &ListCertificateDomainValidationsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ListCertificateDomainValidations", params, optFns, c.addOperationListCertificateDomainValidationsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ListCertificateDomainValidationsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ListCertificateDomainValidationsInput struct { + + // The Amazon Resource Name (ARN) of the certificate for which to list domain + // validation summaries. + // + // This member is required. + CertificateArn *string + + // The maximum number of domain validation summaries to return. If you don't + // specify a value, the default is 1000. + MaxItems *int32 + + // A token returned by a previous call to ListCertificateDomainValidations . If the + // number of results exceeds MaxItems , use this token to retrieve the next page of + // results. + NextToken *string + + noSmithyDocumentSerde +} + +func (v *ListCertificateDomainValidationsInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListCertificateDomainValidationsRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListCertificateDomainValidationsInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.ListCertificateDomainValidationsRequest_CertificateArn, *v.CertificateArn) + } + if v.MaxItems != nil { + s.WriteInt32(schemas.ListCertificateDomainValidationsRequest_MaxItems, *v.MaxItems) + } + if v.NextToken != nil { + s.WriteString(schemas.ListCertificateDomainValidationsRequest_NextToken, *v.NextToken) + } +} +func (in *ListCertificateDomainValidationsInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + +type ListCertificateDomainValidationsOutput struct { + + // A list of DomainValidationSummary objects, one for each domain on the certificate. Each object + // contains the domain name and its active and requested validation configurations. + DomainValidationSummaryList []types.DomainValidationSummary + + // If the number of results exceeds MaxItems , this token is included in the + // response. Use this token in a subsequent ListCertificateDomainValidations + // request to retrieve the next page of results. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *ListCertificateDomainValidationsOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListCertificateDomainValidationsResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListCertificateDomainValidationsOutput) SerializeMembers(s smithy.ShapeSerializer) { + serializeDomainValidationSummaryList(s, schemas.ListCertificateDomainValidationsResponse_DomainValidationSummaryList, v.DomainValidationSummaryList) + if v.NextToken != nil { + s.WriteString(schemas.ListCertificateDomainValidationsResponse_NextToken, *v.NextToken) + } +} +func (v *ListCertificateDomainValidationsOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ListCertificateDomainValidationsResponse, func(s *smithy.Schema) error { + switch s { + case schemas.ListCertificateDomainValidationsResponse_DomainValidationSummaryList: + return deserializeDomainValidationSummaryList(d, schemas.ListCertificateDomainValidationsResponse_DomainValidationSummaryList, &v.DomainValidationSummaryList) + case schemas.ListCertificateDomainValidationsResponse_NextToken: + v.NextToken = new(string) + return d.ReadString(schemas.ListCertificateDomainValidationsResponse_NextToken, v.NextToken) + } + return nil + }) +} +func (c *Client) addOperationListCertificateDomainValidationsMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListCertificateDomainValidations, schemas.ListCertificateDomainValidationsRequest, schemas.ListCertificateDomainValidationsResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListCertificateDomainValidations, schemas.ListCertificateDomainValidationsRequest, schemas.ListCertificateDomainValidationsResponse), output: &ListCertificateDomainValidationsOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpListCertificateDomainValidationsValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// ListCertificateDomainValidationsPaginatorOptions is the paginator options for +// ListCertificateDomainValidations +type ListCertificateDomainValidationsPaginatorOptions struct { + // The maximum number of domain validation summaries to return. If you don't + // specify a value, the default is 1000. + 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 +} + +// ListCertificateDomainValidationsPaginator is a paginator for +// ListCertificateDomainValidations +type ListCertificateDomainValidationsPaginator struct { + options ListCertificateDomainValidationsPaginatorOptions + client ListCertificateDomainValidationsAPIClient + params *ListCertificateDomainValidationsInput + nextToken *string + firstPage bool +} + +// NewListCertificateDomainValidationsPaginator returns a new +// ListCertificateDomainValidationsPaginator +func NewListCertificateDomainValidationsPaginator(client ListCertificateDomainValidationsAPIClient, params *ListCertificateDomainValidationsInput, optFns ...func(*ListCertificateDomainValidationsPaginatorOptions)) *ListCertificateDomainValidationsPaginator { + if params == nil { + params = &ListCertificateDomainValidationsInput{} + } + + options := ListCertificateDomainValidationsPaginatorOptions{} + if params.MaxItems != nil { + options.Limit = *params.MaxItems + } + + for _, fn := range optFns { + fn(&options) + } + + return &ListCertificateDomainValidationsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *ListCertificateDomainValidationsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next ListCertificateDomainValidations page. +func (p *ListCertificateDomainValidationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListCertificateDomainValidationsOutput, 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.MaxItems = limit + + optFns = append([]func(*Options){ + addIsPaginatorUserAgent, + }, optFns...) + result, err := p.client.ListCertificateDomainValidations(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 +} + +// ListCertificateDomainValidationsAPIClient is a client that implements the +// ListCertificateDomainValidations operation. +type ListCertificateDomainValidationsAPIClient interface { + ListCertificateDomainValidations(context.Context, *ListCertificateDomainValidationsInput, ...func(*Options)) (*ListCertificateDomainValidationsOutput, error) +} + +var _ ListCertificateDomainValidationsAPIClient = (*Client)(nil) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListCertificates.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListCertificates.go index 25709fe9d..eadc8b227 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListCertificates.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListCertificates.go @@ -5,16 +5,21 @@ package acm import ( "context" "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Retrieves a list of certificate ARNs and domain names. You can request that // only certificates that match a specific status be listed. You can also filter by // specific attributes of the certificate. Default filtering returns only RSA_2048 // certificates. For more information, see Filters. +// +// By default, this action does not return certificates with a +// CertificateKeyPairOrigin of ACME . To include ACME certificates, specify ACME +// in the CertificateKeyPairOrigins filter. func (c *Client) ListCertificates(ctx context.Context, params *ListCertificatesInput, optFns ...func(*Options)) (*ListCertificatesOutput, error) { if params == nil { params = &ListCertificatesInput{} @@ -32,6 +37,11 @@ func (c *Client) ListCertificates(ctx context.Context, params *ListCertificatesI type ListCertificatesInput struct { + // Filter the certificate list by certificate key pair origin. Specify one or more + // CertificateKeyPairOrigin values. Default filtering returns only certificates + // with key pair origin of AWS_MANAGED and CUSTOMER_PROVIDED . + CertificateKeyPairOrigins []types.CertificateKeyPairOrigin + // Filter the certificate list by status value. CertificateStatuses []types.CertificateStatus @@ -60,6 +70,38 @@ type ListCertificatesInput struct { noSmithyDocumentSerde } +func (v *ListCertificatesInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListCertificatesRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListCertificatesInput) SerializeMembers(s smithy.ShapeSerializer) { + serializeCertificateKeyPairOrigins(s, schemas.ListCertificatesRequest_CertificateKeyPairOrigins, v.CertificateKeyPairOrigins) + serializeCertificateStatuses(s, schemas.ListCertificatesRequest_CertificateStatuses, v.CertificateStatuses) + if v.Includes != nil { + s.WriteStruct(schemas.ListCertificatesRequest_Includes) + v.Includes.SerializeMembers(s) + s.CloseStruct() + } + if v.MaxItems != nil { + s.WriteInt32(schemas.ListCertificatesRequest_MaxItems, *v.MaxItems) + } + if v.NextToken != nil { + s.WriteString(schemas.ListCertificatesRequest_NextToken, *v.NextToken) + } + if v.SortBy != "" { + s.WriteString(schemas.ListCertificatesRequest_SortBy, string(v.SortBy)) + } + if v.SortOrder != "" { + s.WriteString(schemas.ListCertificatesRequest_SortOrder, string(v.SortOrder)) + } +} +func (in *ListCertificatesInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type ListCertificatesOutput struct { // A list of ACM certificates. @@ -75,76 +117,50 @@ type ListCertificatesOutput struct { noSmithyDocumentSerde } -func (c *Client) addOperationListCertificatesMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpListCertificates{}, middleware.After) - if err != nil { - return err - } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListCertificates{}, middleware.After) - if err != nil { - return err - } - if err := addProtocolFinalizerMiddlewares(stack, options, "ListCertificates"); err != nil { - return fmt.Errorf("add protocol finalizers: %v", err) - } +func (v *ListCertificatesOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListCertificatesResponse) + v.SerializeMembers(s) + s.CloseStruct() +} - if err = addlegacyEndpointContextSetter(stack, options); err != nil { - return err - } - if err = addSetLoggerMiddleware(stack, options); err != nil { - return err +func (v *ListCertificatesOutput) SerializeMembers(s smithy.ShapeSerializer) { + serializeCertificateSummaryList(s, schemas.ListCertificatesResponse_CertificateSummaryList, v.CertificateSummaryList) + if v.NextToken != nil { + s.WriteString(schemas.ListCertificatesResponse_NextToken, *v.NextToken) } - if err = addClientRequestID(stack); err != nil { +} +func (v *ListCertificatesOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ListCertificatesResponse, func(s *smithy.Schema) error { + switch s { + case schemas.ListCertificatesResponse_CertificateSummaryList: + return deserializeCertificateSummaryList(d, schemas.ListCertificatesResponse_CertificateSummaryList, &v.CertificateSummaryList) + case schemas.ListCertificatesResponse_NextToken: + v.NextToken = new(string) + return d.ReadString(schemas.ListCertificatesResponse_NextToken, v.NextToken) + } + return nil + }) +} +func (c *Client) addOperationListCertificatesMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListCertificates, schemas.ListCertificatesRequest, schemas.ListCertificatesResponse)}, middleware.After); err != nil { return err } - if err = addComputeContentLength(stack); err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListCertificates, schemas.ListCertificatesRequest, schemas.ListCertificatesResponse), output: &ListCertificatesOutput{}}, middleware.After); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListCertificates(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -157,12 +173,6 @@ func (c *Client) addOperationListCertificatesMiddlewares(stack *middleware.Stack 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 } @@ -264,11 +274,3 @@ type ListCertificatesAPIClient interface { } var _ ListCertificatesAPIClient = (*Client)(nil) - -func newServiceMetadataMiddleware_opListCertificates(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "ListCertificates", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListTagsForCertificate.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListTagsForCertificate.go index 194158774..e5c98016f 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListTagsForCertificate.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListTagsForCertificate.go @@ -4,16 +4,19 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Lists the tags that have been applied to the ACM certificate. Use the // certificate's Amazon Resource Name (ARN) to specify the certificate. To add a // tag to an ACM certificate, use the AddTagsToCertificateaction. To delete a tag, use the RemoveTagsFromCertificate action. +// +// This action applies only to the certificate resource type. For all other ACM +// resource types, use ListTagsForResourceinstead. func (c *Client) ListTagsForCertificate(ctx context.Context, params *ListTagsForCertificateInput, optFns ...func(*Options)) (*ListTagsForCertificateOutput, error) { if params == nil { params = &ListTagsForCertificateInput{} @@ -46,6 +49,22 @@ type ListTagsForCertificateInput struct { noSmithyDocumentSerde } +func (v *ListTagsForCertificateInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListTagsForCertificateRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListTagsForCertificateInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.ListTagsForCertificateRequest_CertificateArn, *v.CertificateArn) + } +} +func (in *ListTagsForCertificateInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type ListTagsForCertificateOutput struct { // The key-value pairs that define the applied tags. @@ -57,65 +76,39 @@ type ListTagsForCertificateOutput struct { noSmithyDocumentSerde } +func (v *ListTagsForCertificateOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListTagsForCertificateResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListTagsForCertificateOutput) SerializeMembers(s smithy.ShapeSerializer) { + serializeTagList(s, schemas.ListTagsForCertificateResponse_Tags, v.Tags) +} +func (v *ListTagsForCertificateOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ListTagsForCertificateResponse, func(s *smithy.Schema) error { + switch s { + case schemas.ListTagsForCertificateResponse_Tags: + return deserializeTagList(d, schemas.ListTagsForCertificateResponse_Tags, &v.Tags) + } + return nil + }) +} func (c *Client) addOperationListTagsForCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpListTagsForCertificate{}, middleware.After) - if err != nil { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListTagsForCertificate, schemas.ListTagsForCertificateRequest, schemas.ListTagsForCertificateResponse)}, middleware.After); err != nil { return err } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListTagsForCertificate{}, middleware.After) - if err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListTagsForCertificate, schemas.ListTagsForCertificateRequest, schemas.ListTagsForCertificateResponse), output: &ListTagsForCertificateOutput{}}, middleware.After); err != nil { return err } - if err := addProtocolFinalizerMiddlewares(stack, options, "ListTagsForCertificate"); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -124,12 +117,6 @@ func (c *Client) addOperationListTagsForCertificateMiddlewares(stack *middleware if err = addOpListTagsForCertificateValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListTagsForCertificate(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -142,22 +129,8 @@ func (c *Client) addOperationListTagsForCertificateMiddlewares(stack *middleware 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 } - -func newServiceMetadataMiddleware_opListTagsForCertificate(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "ListTagsForCertificate", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListTagsForResource.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListTagsForResource.go new file mode 100644 index 000000000..59cf67982 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ListTagsForResource.go @@ -0,0 +1,130 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Lists the tags associated with an ACM resource. +// +// Use this action for all ACM resource types except the certificate resource +// type. For certificate resources, use ListTagsForCertificateinstead. +// +// To add one or more tags, use the TagResource action. To remove one or more tags, use the UntagResource +// action. +func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error) { + if params == nil { + params = &ListTagsForResourceInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ListTagsForResource", params, optFns, c.addOperationListTagsForResourceMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ListTagsForResourceOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ListTagsForResourceInput struct { + + // The ARN of the ACM resource for which to list tags. + // + // This member is required. + ResourceArn *string + + noSmithyDocumentSerde +} + +func (v *ListTagsForResourceInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListTagsForResourceRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListTagsForResourceInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.ResourceArn != nil { + s.WriteString(schemas.ListTagsForResourceRequest_ResourceArn, *v.ResourceArn) + } +} +func (in *ListTagsForResourceInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + +type ListTagsForResourceOutput struct { + + // The tags associated with the resource. + Tags []types.Tag + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *ListTagsForResourceOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListTagsForResourceResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListTagsForResourceOutput) SerializeMembers(s smithy.ShapeSerializer) { + serializeTagList(s, schemas.ListTagsForResourceResponse_Tags, v.Tags) +} +func (v *ListTagsForResourceOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ListTagsForResourceResponse, func(s *smithy.Schema) error { + switch s { + case schemas.ListTagsForResourceResponse_Tags: + return deserializeTagList(d, schemas.ListTagsForResourceResponse_Tags, &v.Tags) + } + return nil + }) +} +func (c *Client) addOperationListTagsForResourceMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListTagsForResource, schemas.ListTagsForResourceRequest, schemas.ListTagsForResourceResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListTagsForResource, schemas.ListTagsForResourceRequest, schemas.ListTagsForResourceResponse), output: &ListTagsForResourceOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpListTagsForResourceValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_PutAccountConfiguration.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_PutAccountConfiguration.go index f4720a179..e41723143 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_PutAccountConfiguration.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_PutAccountConfiguration.go @@ -4,11 +4,11 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Adds or modifies account-level configurations in ACM. @@ -51,6 +51,27 @@ type PutAccountConfigurationInput struct { noSmithyDocumentSerde } +func (v *PutAccountConfigurationInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.PutAccountConfigurationRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *PutAccountConfigurationInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.ExpiryEvents != nil { + s.WriteStruct(schemas.PutAccountConfigurationRequest_ExpiryEvents) + v.ExpiryEvents.SerializeMembers(s) + s.CloseStruct() + } + if v.IdempotencyToken != nil { + s.WriteString(schemas.PutAccountConfigurationRequest_IdempotencyToken, *v.IdempotencyToken) + } +} +func (in *PutAccountConfigurationInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type PutAccountConfigurationOutput struct { // Metadata pertaining to the operation's result. ResultMetadata middleware.Metadata @@ -58,65 +79,36 @@ type PutAccountConfigurationOutput struct { noSmithyDocumentSerde } +func (v *PutAccountConfigurationOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *PutAccountConfigurationOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *PutAccountConfigurationOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} func (c *Client) addOperationPutAccountConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpPutAccountConfiguration{}, middleware.After) - if err != nil { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.PutAccountConfiguration, schemas.PutAccountConfigurationRequest, nil)}, middleware.After); err != nil { return err } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpPutAccountConfiguration{}, middleware.After) - if err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.PutAccountConfiguration, schemas.PutAccountConfigurationRequest, nil), output: &PutAccountConfigurationOutput{}}, middleware.After); err != nil { return err } - if err := addProtocolFinalizerMiddlewares(stack, options, "PutAccountConfiguration"); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -125,12 +117,6 @@ func (c *Client) addOperationPutAccountConfigurationMiddlewares(stack *middlewar if err = addOpPutAccountConfigurationValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutAccountConfiguration(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -143,22 +129,8 @@ func (c *Client) addOperationPutAccountConfigurationMiddlewares(stack *middlewar 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 } - -func newServiceMetadataMiddleware_opPutAccountConfiguration(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "PutAccountConfiguration", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RemoveTagsFromCertificate.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RemoveTagsFromCertificate.go index 550e4cd8e..1527fb2c3 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RemoveTagsFromCertificate.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RemoveTagsFromCertificate.go @@ -4,11 +4,11 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Remove one or more tags from an ACM certificate. A tag consists of a key-value @@ -16,6 +16,9 @@ import ( // function, the tag will be removed regardless of value. If you specify a value, // the tag is removed only if it is associated with the specified value. // +// This action applies only to the certificate resource type. For all other ACM +// resource types, use UntagResourceinstead. +// // To add tags to a certificate, use the AddTagsToCertificate action. To view all of the tags that // have been applied to a specific ACM certificate, use the ListTagsForCertificateaction. func (c *Client) RemoveTagsFromCertificate(ctx context.Context, params *RemoveTagsFromCertificateInput, optFns ...func(*Options)) (*RemoveTagsFromCertificateOutput, error) { @@ -55,6 +58,23 @@ type RemoveTagsFromCertificateInput struct { noSmithyDocumentSerde } +func (v *RemoveTagsFromCertificateInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RemoveTagsFromCertificateRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RemoveTagsFromCertificateInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.RemoveTagsFromCertificateRequest_CertificateArn, *v.CertificateArn) + } + serializeTagList(s, schemas.RemoveTagsFromCertificateRequest_Tags, v.Tags) +} +func (in *RemoveTagsFromCertificateInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type RemoveTagsFromCertificateOutput struct { // Metadata pertaining to the operation's result. ResultMetadata middleware.Metadata @@ -62,65 +82,36 @@ type RemoveTagsFromCertificateOutput struct { noSmithyDocumentSerde } +func (v *RemoveTagsFromCertificateOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RemoveTagsFromCertificateOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *RemoveTagsFromCertificateOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} func (c *Client) addOperationRemoveTagsFromCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpRemoveTagsFromCertificate{}, middleware.After) - if err != nil { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.RemoveTagsFromCertificate, schemas.RemoveTagsFromCertificateRequest, nil)}, middleware.After); err != nil { return err } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpRemoveTagsFromCertificate{}, middleware.After) - if err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.RemoveTagsFromCertificate, schemas.RemoveTagsFromCertificateRequest, nil), output: &RemoveTagsFromCertificateOutput{}}, middleware.After); err != nil { return err } - if err := addProtocolFinalizerMiddlewares(stack, options, "RemoveTagsFromCertificate"); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -129,12 +120,6 @@ func (c *Client) addOperationRemoveTagsFromCertificateMiddlewares(stack *middlew if err = addOpRemoveTagsFromCertificateValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRemoveTagsFromCertificate(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -147,22 +132,8 @@ func (c *Client) addOperationRemoveTagsFromCertificateMiddlewares(stack *middlew 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 } - -func newServiceMetadataMiddleware_opRemoveTagsFromCertificate(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "RemoveTagsFromCertificate", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RenewCertificate.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RenewCertificate.go index a6579fe40..c61999931 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RenewCertificate.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RenewCertificate.go @@ -4,10 +4,10 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Renews an [eligible ACM certificate]. In order to renew your Amazon Web Services Private CA certificates @@ -48,6 +48,22 @@ type RenewCertificateInput struct { noSmithyDocumentSerde } +func (v *RenewCertificateInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RenewCertificateRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RenewCertificateInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.RenewCertificateRequest_CertificateArn, *v.CertificateArn) + } +} +func (in *RenewCertificateInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type RenewCertificateOutput struct { // Metadata pertaining to the operation's result. ResultMetadata middleware.Metadata @@ -55,65 +71,36 @@ type RenewCertificateOutput struct { noSmithyDocumentSerde } +func (v *RenewCertificateOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RenewCertificateOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *RenewCertificateOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} func (c *Client) addOperationRenewCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpRenewCertificate{}, middleware.After) - if err != nil { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.RenewCertificate, schemas.RenewCertificateRequest, nil)}, middleware.After); err != nil { return err } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpRenewCertificate{}, middleware.After) - if err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.RenewCertificate, schemas.RenewCertificateRequest, nil), output: &RenewCertificateOutput{}}, middleware.After); err != nil { return err } - if err := addProtocolFinalizerMiddlewares(stack, options, "RenewCertificate"); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -122,12 +109,6 @@ func (c *Client) addOperationRenewCertificateMiddlewares(stack *middleware.Stack if err = addOpRenewCertificateValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRenewCertificate(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -140,22 +121,8 @@ func (c *Client) addOperationRenewCertificateMiddlewares(stack *middleware.Stack 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 } - -func newServiceMetadataMiddleware_opRenewCertificate(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "RenewCertificate", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RequestCertificate.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RequestCertificate.go index a457a356c..ffb22acdd 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RequestCertificate.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RequestCertificate.go @@ -4,11 +4,11 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Requests an ACM certificate for use with other Amazon Web Services services. To @@ -122,19 +122,17 @@ type RequestCertificateInput struct { // by ACM. ManagedBy types.CertificateManagedBy - // You can use this parameter to specify whether to add the certificate to a - // certificate transparency log and export your certificate. + // You can use this parameter to specify whether to export your certificate. // - // Certificate transparency makes it possible to detect SSL/TLS certificates that - // have been mistakenly or maliciously issued. Certificates that have not been - // logged typically produce an error message in a browser. For more information, - // see [Opting Out of Certificate Transparency Logging]. + // Certificate transparency logging opt-out is no longer available. All public + // certificates are recorded in a certificate transparency log. For more + // information, see [Certificate Transparency Logging]. // // You can export public ACM certificates to use with Amazon Web Services services // as well as outside the Amazon Web Services Cloud. For more information, see [Certificate Manager exportable public certificate]. // - // [Opting Out of Certificate Transparency Logging]: https://docs.aws.amazon.com/acm/latest/userguide/acm-bestpractices.html#best-practices-transparency // [Certificate Manager exportable public certificate]: https://docs.aws.amazon.com/acm/latest/userguide/acm-exportable-certificates.html + // [Certificate Transparency Logging]: https://docs.aws.amazon.com/acm/latest/userguide/acm-concepts.html#concept-transparency Options *types.CertificateOptions // Additional FQDNs to be included in the Subject Alternative Name extension of @@ -176,6 +174,45 @@ type RequestCertificateInput struct { noSmithyDocumentSerde } +func (v *RequestCertificateInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RequestCertificateRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RequestCertificateInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateAuthorityArn != nil { + s.WriteString(schemas.RequestCertificateRequest_CertificateAuthorityArn, *v.CertificateAuthorityArn) + } + if v.DomainName != nil { + s.WriteString(schemas.RequestCertificateRequest_DomainName, *v.DomainName) + } + serializeDomainValidationOptionList(s, schemas.RequestCertificateRequest_DomainValidationOptions, v.DomainValidationOptions) + if v.IdempotencyToken != nil { + s.WriteString(schemas.RequestCertificateRequest_IdempotencyToken, *v.IdempotencyToken) + } + if v.KeyAlgorithm != "" { + s.WriteString(schemas.RequestCertificateRequest_KeyAlgorithm, string(v.KeyAlgorithm)) + } + if v.ManagedBy != "" { + s.WriteString(schemas.RequestCertificateRequest_ManagedBy, string(v.ManagedBy)) + } + if v.Options != nil { + s.WriteStruct(schemas.RequestCertificateRequest_Options) + v.Options.SerializeMembers(s) + s.CloseStruct() + } + serializeDomainList(s, schemas.RequestCertificateRequest_SubjectAlternativeNames, v.SubjectAlternativeNames) + serializeTagList(s, schemas.RequestCertificateRequest_Tags, v.Tags) + if v.ValidationMethod != "" { + s.WriteString(schemas.RequestCertificateRequest_ValidationMethod, string(v.ValidationMethod)) + } +} +func (in *RequestCertificateInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type RequestCertificateOutput struct { // String that contains the ARN of the issued certificate. This must be of the @@ -190,65 +227,42 @@ type RequestCertificateOutput struct { noSmithyDocumentSerde } -func (c *Client) addOperationRequestCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpRequestCertificate{}, middleware.After) - if err != nil { - return err - } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpRequestCertificate{}, middleware.After) - if err != nil { - return err - } - if err := addProtocolFinalizerMiddlewares(stack, options, "RequestCertificate"); err != nil { - return fmt.Errorf("add protocol finalizers: %v", err) - } +func (v *RequestCertificateOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RequestCertificateResponse) + v.SerializeMembers(s) + s.CloseStruct() +} - if err = addlegacyEndpointContextSetter(stack, options); err != nil { - return err +func (v *RequestCertificateOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.RequestCertificateResponse_CertificateArn, *v.CertificateArn) } - if err = addSetLoggerMiddleware(stack, options); err != nil { - return err - } - if err = addClientRequestID(stack); err != nil { +} +func (v *RequestCertificateOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RequestCertificateResponse, func(s *smithy.Schema) error { + switch s { + case schemas.RequestCertificateResponse_CertificateArn: + v.CertificateArn = new(string) + return d.ReadString(schemas.RequestCertificateResponse_CertificateArn, v.CertificateArn) + } + return nil + }) +} +func (c *Client) addOperationRequestCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.RequestCertificate, schemas.RequestCertificateRequest, schemas.RequestCertificateResponse)}, middleware.After); err != nil { return err } - if err = addComputeContentLength(stack); err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.RequestCertificate, schemas.RequestCertificateRequest, schemas.RequestCertificateResponse), output: &RequestCertificateOutput{}}, middleware.After); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -257,12 +271,6 @@ func (c *Client) addOperationRequestCertificateMiddlewares(stack *middleware.Sta if err = addOpRequestCertificateValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRequestCertificate(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -275,22 +283,8 @@ func (c *Client) addOperationRequestCertificateMiddlewares(stack *middleware.Sta 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 } - -func newServiceMetadataMiddleware_opRequestCertificate(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "RequestCertificate", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ResendValidationEmail.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ResendValidationEmail.go index 30049bc11..d08443cae 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ResendValidationEmail.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_ResendValidationEmail.go @@ -4,10 +4,10 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Resends the email that requests domain ownership validation. The domain owner @@ -77,6 +77,28 @@ type ResendValidationEmailInput struct { noSmithyDocumentSerde } +func (v *ResendValidationEmailInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ResendValidationEmailRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ResendValidationEmailInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.ResendValidationEmailRequest_CertificateArn, *v.CertificateArn) + } + if v.Domain != nil { + s.WriteString(schemas.ResendValidationEmailRequest_Domain, *v.Domain) + } + if v.ValidationDomain != nil { + s.WriteString(schemas.ResendValidationEmailRequest_ValidationDomain, *v.ValidationDomain) + } +} +func (in *ResendValidationEmailInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type ResendValidationEmailOutput struct { // Metadata pertaining to the operation's result. ResultMetadata middleware.Metadata @@ -84,65 +106,36 @@ type ResendValidationEmailOutput struct { noSmithyDocumentSerde } +func (v *ResendValidationEmailOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ResendValidationEmailOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *ResendValidationEmailOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} func (c *Client) addOperationResendValidationEmailMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ResendValidationEmail, schemas.ResendValidationEmailRequest, nil)}, middleware.After); err != nil { return err } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpResendValidationEmail{}, middleware.After) - if err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ResendValidationEmail, schemas.ResendValidationEmailRequest, nil), output: &ResendValidationEmailOutput{}}, middleware.After); err != nil { return err } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpResendValidationEmail{}, middleware.After) - if err != nil { - return err - } - if err := addProtocolFinalizerMiddlewares(stack, options, "ResendValidationEmail"); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -151,12 +144,6 @@ func (c *Client) addOperationResendValidationEmailMiddlewares(stack *middleware. if err = addOpResendValidationEmailValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opResendValidationEmail(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -169,22 +156,8 @@ func (c *Client) addOperationResendValidationEmailMiddlewares(stack *middleware. 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 } - -func newServiceMetadataMiddleware_opResendValidationEmail(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "ResendValidationEmail", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RevokeAcmeAccount.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RevokeAcmeAccount.go new file mode 100644 index 000000000..2b16e2a7d --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RevokeAcmeAccount.go @@ -0,0 +1,125 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Revokes an ACME account, preventing it from requesting or revoking +// certificates. This operation is irreversible. +func (c *Client) RevokeAcmeAccount(ctx context.Context, params *RevokeAcmeAccountInput, optFns ...func(*Options)) (*RevokeAcmeAccountOutput, error) { + if params == nil { + params = &RevokeAcmeAccountInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "RevokeAcmeAccount", params, optFns, c.addOperationRevokeAcmeAccountMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*RevokeAcmeAccountOutput) + out.ResultMetadata = metadata + return out, nil +} + +type RevokeAcmeAccountInput struct { + + // The URL of the ACME account to revoke. + // + // This member is required. + AccountUrl *string + + // The Amazon Resource Name (ARN) of the ACME endpoint. + // + // This member is required. + AcmeEndpointArn *string + + noSmithyDocumentSerde +} + +func (v *RevokeAcmeAccountInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RevokeAcmeAccountRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RevokeAcmeAccountInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AccountUrl != nil { + s.WriteString(schemas.RevokeAcmeAccountRequest_AccountUrl, *v.AccountUrl) + } + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.RevokeAcmeAccountRequest_AcmeEndpointArn, *v.AcmeEndpointArn) + } +} +func (in *RevokeAcmeAccountInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type RevokeAcmeAccountOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *RevokeAcmeAccountOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RevokeAcmeAccountOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *RevokeAcmeAccountOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} +func (c *Client) addOperationRevokeAcmeAccountMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.RevokeAcmeAccount, schemas.RevokeAcmeAccountRequest, nil)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.RevokeAcmeAccount, schemas.RevokeAcmeAccountRequest, nil), output: &RevokeAcmeAccountOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpRevokeAcmeAccountValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RevokeAcmeExternalAccountBinding.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RevokeAcmeExternalAccountBinding.go new file mode 100644 index 000000000..073862957 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RevokeAcmeExternalAccountBinding.go @@ -0,0 +1,118 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Revokes an external account binding, preventing new ACME accounts from being +// registered using this binding. Existing ACME accounts that were previously +// registered using the binding are not affected and must be revoked separately. +func (c *Client) RevokeAcmeExternalAccountBinding(ctx context.Context, params *RevokeAcmeExternalAccountBindingInput, optFns ...func(*Options)) (*RevokeAcmeExternalAccountBindingOutput, error) { + if params == nil { + params = &RevokeAcmeExternalAccountBindingInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "RevokeAcmeExternalAccountBinding", params, optFns, c.addOperationRevokeAcmeExternalAccountBindingMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*RevokeAcmeExternalAccountBindingOutput) + out.ResultMetadata = metadata + return out, nil +} + +type RevokeAcmeExternalAccountBindingInput struct { + + // The Amazon Resource Name (ARN) of the ACME external account binding to revoke. + // + // This member is required. + AcmeExternalAccountBindingArn *string + + noSmithyDocumentSerde +} + +func (v *RevokeAcmeExternalAccountBindingInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RevokeAcmeExternalAccountBindingRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RevokeAcmeExternalAccountBindingInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeExternalAccountBindingArn != nil { + s.WriteString(schemas.RevokeAcmeExternalAccountBindingRequest_AcmeExternalAccountBindingArn, *v.AcmeExternalAccountBindingArn) + } +} +func (in *RevokeAcmeExternalAccountBindingInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type RevokeAcmeExternalAccountBindingOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *RevokeAcmeExternalAccountBindingOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RevokeAcmeExternalAccountBindingOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *RevokeAcmeExternalAccountBindingOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} +func (c *Client) addOperationRevokeAcmeExternalAccountBindingMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.RevokeAcmeExternalAccountBinding, schemas.RevokeAcmeExternalAccountBindingRequest, nil)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.RevokeAcmeExternalAccountBinding, schemas.RevokeAcmeExternalAccountBindingRequest, nil), output: &RevokeAcmeExternalAccountBindingOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpRevokeAcmeExternalAccountBindingValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RevokeCertificate.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RevokeCertificate.go index e8e488570..4a615a83f 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RevokeCertificate.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_RevokeCertificate.go @@ -4,11 +4,11 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Revokes a public ACM certificate. You can only revoke certificates that have @@ -49,6 +49,25 @@ type RevokeCertificateInput struct { noSmithyDocumentSerde } +func (v *RevokeCertificateInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RevokeCertificateRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RevokeCertificateInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.RevokeCertificateRequest_CertificateArn, *v.CertificateArn) + } + if v.RevocationReason != "" { + s.WriteString(schemas.RevokeCertificateRequest_RevocationReason, string(v.RevocationReason)) + } +} +func (in *RevokeCertificateInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type RevokeCertificateOutput struct { // The Amazon Resource Name (ARN) of the public or private certificate that was @@ -61,65 +80,42 @@ type RevokeCertificateOutput struct { noSmithyDocumentSerde } -func (c *Client) addOperationRevokeCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpRevokeCertificate{}, middleware.After) - if err != nil { - return err - } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpRevokeCertificate{}, middleware.After) - if err != nil { - return err - } - if err := addProtocolFinalizerMiddlewares(stack, options, "RevokeCertificate"); err != nil { - return fmt.Errorf("add protocol finalizers: %v", err) - } +func (v *RevokeCertificateOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RevokeCertificateResponse) + v.SerializeMembers(s) + s.CloseStruct() +} - if err = addlegacyEndpointContextSetter(stack, options); err != nil { - return err +func (v *RevokeCertificateOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.RevokeCertificateResponse_CertificateArn, *v.CertificateArn) } - if err = addSetLoggerMiddleware(stack, options); err != nil { - return err - } - if err = addClientRequestID(stack); err != nil { +} +func (v *RevokeCertificateOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RevokeCertificateResponse, func(s *smithy.Schema) error { + switch s { + case schemas.RevokeCertificateResponse_CertificateArn: + v.CertificateArn = new(string) + return d.ReadString(schemas.RevokeCertificateResponse_CertificateArn, v.CertificateArn) + } + return nil + }) +} +func (c *Client) addOperationRevokeCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.RevokeCertificate, schemas.RevokeCertificateRequest, schemas.RevokeCertificateResponse)}, middleware.After); err != nil { return err } - if err = addComputeContentLength(stack); err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.RevokeCertificate, schemas.RevokeCertificateRequest, schemas.RevokeCertificateResponse), output: &RevokeCertificateOutput{}}, middleware.After); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -128,12 +124,6 @@ func (c *Client) addOperationRevokeCertificateMiddlewares(stack *middleware.Stac if err = addOpRevokeCertificateValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRevokeCertificate(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -146,22 +136,8 @@ func (c *Client) addOperationRevokeCertificateMiddlewares(stack *middleware.Stac 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 } - -func newServiceMetadataMiddleware_opRevokeCertificate(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "RevokeCertificate", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_SearchCertificates.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_SearchCertificates.go index 40e470f24..7532b5150 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_SearchCertificates.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_SearchCertificates.go @@ -5,10 +5,11 @@ package acm import ( "context" "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) // Retrieves a list of certificates matching search criteria. You can filter @@ -56,6 +57,32 @@ type SearchCertificatesInput struct { noSmithyDocumentSerde } +func (v *SearchCertificatesInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.SearchCertificatesRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *SearchCertificatesInput) SerializeMembers(s smithy.ShapeSerializer) { + serializeCertificateFilterStatement(s, schemas.SearchCertificatesRequest_FilterStatement, v.FilterStatement) + if v.MaxResults != nil { + s.WriteInt32(schemas.SearchCertificatesRequest_MaxResults, *v.MaxResults) + } + if v.NextToken != nil { + s.WriteString(schemas.SearchCertificatesRequest_NextToken, *v.NextToken) + } + if v.SortBy != "" { + s.WriteString(schemas.SearchCertificatesRequest_SortBy, string(v.SortBy)) + } + if v.SortOrder != "" { + s.WriteString(schemas.SearchCertificatesRequest_SortOrder, string(v.SortOrder)) + } +} +func (in *SearchCertificatesInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type SearchCertificatesOutput struct { // When the list is truncated, this value is present and contains the value to use @@ -72,65 +99,45 @@ type SearchCertificatesOutput struct { noSmithyDocumentSerde } -func (c *Client) addOperationSearchCertificatesMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { - return err - } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpSearchCertificates{}, middleware.After) - if err != nil { - return err - } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpSearchCertificates{}, middleware.After) - if err != nil { - return err - } - if err := addProtocolFinalizerMiddlewares(stack, options, "SearchCertificates"); err != nil { - return fmt.Errorf("add protocol finalizers: %v", err) - } +func (v *SearchCertificatesOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.SearchCertificatesResponse) + v.SerializeMembers(s) + s.CloseStruct() +} - if err = addlegacyEndpointContextSetter(stack, options); err != nil { - return err - } - if err = addSetLoggerMiddleware(stack, options); err != nil { - return err +func (v *SearchCertificatesOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.NextToken != nil { + s.WriteString(schemas.SearchCertificatesResponse_NextToken, *v.NextToken) } - if err = addClientRequestID(stack); err != nil { + serializeCertificateSearchResultList(s, schemas.SearchCertificatesResponse_Results, v.Results) +} +func (v *SearchCertificatesOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.SearchCertificatesResponse, func(s *smithy.Schema) error { + switch s { + case schemas.SearchCertificatesResponse_NextToken: + v.NextToken = new(string) + return d.ReadString(schemas.SearchCertificatesResponse_NextToken, v.NextToken) + case schemas.SearchCertificatesResponse_Results: + return deserializeCertificateSearchResultList(d, schemas.SearchCertificatesResponse_Results, &v.Results) + } + return nil + }) +} +func (c *Client) addOperationSearchCertificatesMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.SearchCertificates, schemas.SearchCertificatesRequest, schemas.SearchCertificatesResponse)}, middleware.After); err != nil { return err } - if err = addComputeContentLength(stack); err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.SearchCertificates, schemas.SearchCertificatesRequest, schemas.SearchCertificatesResponse), output: &SearchCertificatesOutput{}}, middleware.After); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -139,12 +146,6 @@ func (c *Client) addOperationSearchCertificatesMiddlewares(stack *middleware.Sta if err = addOpSearchCertificatesValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSearchCertificates(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -157,12 +158,6 @@ func (c *Client) addOperationSearchCertificatesMiddlewares(stack *middleware.Sta 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 } @@ -262,11 +257,3 @@ type SearchCertificatesAPIClient interface { } var _ SearchCertificatesAPIClient = (*Client)(nil) - -func newServiceMetadataMiddleware_opSearchCertificates(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "SearchCertificates", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_TagResource.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_TagResource.go new file mode 100644 index 000000000..154daeea2 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_TagResource.go @@ -0,0 +1,131 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Adds one or more tags to an ACM resource. Tags are labels that you can use to +// identify and organize your Amazon Web Services resources. Each tag consists of a +// key and an optional value . +// +// Use this action for all ACM resource types except the certificate resource +// type. For certificate resources, use AddTagsToCertificateinstead. +// +// To remove one or more tags, use the UntagResource action. To view all of the tags that have +// been applied to a resource, use the ListTagsForResourceaction. +func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error) { + if params == nil { + params = &TagResourceInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "TagResource", params, optFns, c.addOperationTagResourceMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*TagResourceOutput) + out.ResultMetadata = metadata + return out, nil +} + +type TagResourceInput struct { + + // The ARN of the ACM resource to which the tag is to be applied. + // + // This member is required. + ResourceArn *string + + // The key-value pair that defines the tag to apply. + // + // This member is required. + Tags []types.Tag + + noSmithyDocumentSerde +} + +func (v *TagResourceInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.TagResourceRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *TagResourceInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.ResourceArn != nil { + s.WriteString(schemas.TagResourceRequest_ResourceArn, *v.ResourceArn) + } + serializeTagList(s, schemas.TagResourceRequest_Tags, v.Tags) +} +func (in *TagResourceInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + +type TagResourceOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *TagResourceOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *TagResourceOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *TagResourceOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} +func (c *Client) addOperationTagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.TagResource, schemas.TagResourceRequest, nil)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.TagResource, schemas.TagResourceRequest, nil), output: &TagResourceOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpTagResourceValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_UntagResource.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_UntagResource.go new file mode 100644 index 000000000..b0100525e --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_UntagResource.go @@ -0,0 +1,128 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Removes one or more tags from an ACM resource. +// +// Use this action for all ACM resource types except the certificate resource +// type. For certificate resources, use RemoveTagsFromCertificateinstead. +// +// To add one or more tags, use the TagResource action. To view all of the tags that have +// been applied to a resource, use the ListTagsForResourceaction. +func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error) { + if params == nil { + params = &UntagResourceInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "UntagResource", params, optFns, c.addOperationUntagResourceMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*UntagResourceOutput) + out.ResultMetadata = metadata + return out, nil +} + +type UntagResourceInput struct { + + // The ARN of the ACM resource from which the tag is to be removed. + // + // This member is required. + ResourceArn *string + + // The key of each tag to remove. + // + // This member is required. + TagKeys []string + + noSmithyDocumentSerde +} + +func (v *UntagResourceInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.UntagResourceRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UntagResourceInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.ResourceArn != nil { + s.WriteString(schemas.UntagResourceRequest_ResourceArn, *v.ResourceArn) + } + serializeTagKeyList(s, schemas.UntagResourceRequest_TagKeys, v.TagKeys) +} +func (in *UntagResourceInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + +type UntagResourceOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *UntagResourceOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UntagResourceOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *UntagResourceOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} +func (c *Client) addOperationUntagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.UntagResource, schemas.UntagResourceRequest, nil)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.UntagResource, schemas.UntagResourceRequest, nil), output: &UntagResourceOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpUntagResourceValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_UpdateAcmeDomainValidation.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_UpdateAcmeDomainValidation.go new file mode 100644 index 000000000..125cd3574 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_UpdateAcmeDomainValidation.go @@ -0,0 +1,121 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Updates the prevalidation configuration of an existing domain validation. +func (c *Client) UpdateAcmeDomainValidation(ctx context.Context, params *UpdateAcmeDomainValidationInput, optFns ...func(*Options)) (*UpdateAcmeDomainValidationOutput, error) { + if params == nil { + params = &UpdateAcmeDomainValidationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "UpdateAcmeDomainValidation", params, optFns, c.addOperationUpdateAcmeDomainValidationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*UpdateAcmeDomainValidationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type UpdateAcmeDomainValidationInput struct { + + // The Amazon Resource Name (ARN) of the ACME domain validation to update. + // + // This member is required. + AcmeDomainValidationArn *string + + // The updated prevalidation options. + PrevalidationOptions types.PrevalidationOptions + + noSmithyDocumentSerde +} + +func (v *UpdateAcmeDomainValidationInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.UpdateAcmeDomainValidationRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UpdateAcmeDomainValidationInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeDomainValidationArn != nil { + s.WriteString(schemas.UpdateAcmeDomainValidationRequest_AcmeDomainValidationArn, *v.AcmeDomainValidationArn) + } + serializePrevalidationOptions(s, schemas.UpdateAcmeDomainValidationRequest_PrevalidationOptions, v.PrevalidationOptions) +} +func (in *UpdateAcmeDomainValidationInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type UpdateAcmeDomainValidationOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *UpdateAcmeDomainValidationOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UpdateAcmeDomainValidationOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *UpdateAcmeDomainValidationOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} +func (c *Client) addOperationUpdateAcmeDomainValidationMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.UpdateAcmeDomainValidation, schemas.UpdateAcmeDomainValidationRequest, nil)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.UpdateAcmeDomainValidation, schemas.UpdateAcmeDomainValidationRequest, nil), output: &UpdateAcmeDomainValidationOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpUpdateAcmeDomainValidationValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_UpdateAcmeEndpoint.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_UpdateAcmeEndpoint.go new file mode 100644 index 000000000..70f8bb137 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_UpdateAcmeEndpoint.go @@ -0,0 +1,134 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" +) + +// Updates the configuration of an existing ACME endpoint. You can change the +// authorization behavior, contact requirement, or certificate authority settings. +func (c *Client) UpdateAcmeEndpoint(ctx context.Context, params *UpdateAcmeEndpointInput, optFns ...func(*Options)) (*UpdateAcmeEndpointOutput, error) { + if params == nil { + params = &UpdateAcmeEndpointInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "UpdateAcmeEndpoint", params, optFns, c.addOperationUpdateAcmeEndpointMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*UpdateAcmeEndpointOutput) + out.ResultMetadata = metadata + return out, nil +} + +type UpdateAcmeEndpointInput struct { + + // The Amazon Resource Name (ARN) of the ACME endpoint to update. + // + // This member is required. + AcmeEndpointArn *string + + // The updated authorization behavior. + AuthorizationBehavior types.AcmeAuthorizationBehavior + + // The updated certificate authority configuration. + CertificateAuthority types.CertificateAuthority + + // The updated contact requirement. + Contact types.AcmeContact + + noSmithyDocumentSerde +} + +func (v *UpdateAcmeEndpointInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.UpdateAcmeEndpointRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UpdateAcmeEndpointInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.UpdateAcmeEndpointRequest_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.AuthorizationBehavior != "" { + s.WriteString(schemas.UpdateAcmeEndpointRequest_AuthorizationBehavior, string(v.AuthorizationBehavior)) + } + serializeCertificateAuthority(s, schemas.UpdateAcmeEndpointRequest_CertificateAuthority, v.CertificateAuthority) + if v.Contact != "" { + s.WriteString(schemas.UpdateAcmeEndpointRequest_Contact, string(v.Contact)) + } +} +func (in *UpdateAcmeEndpointInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM-ACME") +} + +type UpdateAcmeEndpointOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *UpdateAcmeEndpointOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UpdateAcmeEndpointOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *UpdateAcmeEndpointOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} +func (c *Client) addOperationUpdateAcmeEndpointMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.UpdateAcmeEndpoint, schemas.UpdateAcmeEndpointRequest, nil)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.UpdateAcmeEndpoint, schemas.UpdateAcmeEndpointRequest, nil), output: &UpdateAcmeEndpointOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpUpdateAcmeEndpointValidationMiddleware(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 = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_UpdateCertificateOptions.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_UpdateCertificateOptions.go index 14d74cd1e..267e29848 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_UpdateCertificateOptions.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/api_op_UpdateCertificateOptions.go @@ -4,19 +4,19 @@ package acm import ( "context" - "fmt" - awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" "github.com/aws/smithy-go/middleware" - smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/ptr" ) -// Updates a certificate. You can use this function to specify whether to opt in -// to or out of recording your certificate in a certificate transparency log and -// exporting. For more information, see [Opting Out of Certificate Transparency Logging]and [Certificate Manager Exportable Managed Certificates]. +// Updates certificate options. You can use this operation to change the domain +// validation method or specify whether to export your certificate. For more +// information, see [Migrate from email to DNS validation]and [Certificate Manager Exportable Managed Certificates]. // -// [Opting Out of Certificate Transparency Logging]: https://docs.aws.amazon.com/acm/latest/userguide/acm-bestpractices.html#best-practices-transparency // [Certificate Manager Exportable Managed Certificates]: https://docs.aws.amazon.com/acm/latest/userguide/acm-exportable-certificates.html +// [Migrate from email to DNS validation]: https://docs.aws.amazon.com/acm/latest/userguide/email-to-dns-migration.html func (c *Client) UpdateCertificateOptions(ctx context.Context, params *UpdateCertificateOptionsInput, optFns ...func(*Options)) (*UpdateCertificateOptionsOutput, error) { if params == nil { params = &UpdateCertificateOptionsInput{} @@ -41,11 +41,11 @@ type UpdateCertificateOptionsInput struct { // This member is required. CertificateArn *string - // Use to update the options for your certificate. Currently, you can specify - // whether to add your certificate to a transparency log or export your - // certificate. Certificate transparency makes it possible to detect SSL/TLS - // certificates that have been mistakenly or maliciously issued. Certificates that - // have not been logged typically produce an error message in a browser. + // Use to update the options for your certificate. Currently, you can change the + // domain validation method or specify whether to export your certificate. For more + // information about migrating from email to DNS validation, see [Migrate from email to DNS validation]. + // + // [Migrate from email to DNS validation]: https://docs.aws.amazon.com/acm/latest/userguide/email-to-dns-migration.html // // This member is required. Options *types.CertificateOptions @@ -53,6 +53,27 @@ type UpdateCertificateOptionsInput struct { noSmithyDocumentSerde } +func (v *UpdateCertificateOptionsInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.UpdateCertificateOptionsRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UpdateCertificateOptionsInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.UpdateCertificateOptionsRequest_CertificateArn, *v.CertificateArn) + } + if v.Options != nil { + s.WriteStruct(schemas.UpdateCertificateOptionsRequest_Options) + v.Options.SerializeMembers(s) + s.CloseStruct() + } +} +func (in *UpdateCertificateOptionsInput) bindEndpointParams(p *EndpointParameters) { + + p.ServiceType = ptr.String("ACM") +} + type UpdateCertificateOptionsOutput struct { // Metadata pertaining to the operation's result. ResultMetadata middleware.Metadata @@ -60,65 +81,36 @@ type UpdateCertificateOptionsOutput struct { noSmithyDocumentSerde } +func (v *UpdateCertificateOptionsOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(nil) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UpdateCertificateOptionsOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *UpdateCertificateOptionsOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, nil, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} func (c *Client) addOperationUpdateCertificateOptionsMiddlewares(stack *middleware.Stack, options Options) (err error) { - if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.UpdateCertificateOptions, schemas.UpdateCertificateOptionsRequest, nil)}, middleware.After); err != nil { return err } - err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateCertificateOptions{}, middleware.After) - if err != nil { + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.UpdateCertificateOptions, schemas.UpdateCertificateOptionsRequest, nil), output: &UpdateCertificateOptionsOutput{}}, middleware.After); err != nil { return err } - err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateCertificateOptions{}, middleware.After) - if err != nil { - return err - } - if err := addProtocolFinalizerMiddlewares(stack, options, "UpdateCertificateOptions"); 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, c); 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 = addUserAgentRetryMode(stack, options); err != nil { + if err = addRecordResponseTiming(stack, options); err != nil { return err } if err = addCredentialSource(stack, options); err != nil { @@ -127,12 +119,6 @@ func (c *Client) addOperationUpdateCertificateOptionsMiddlewares(stack *middlewa if err = addOpUpdateCertificateOptionsValidationMiddleware(stack); err != nil { return err } - if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateCertificateOptions(options.Region), middleware.Before); err != nil { - return err - } - if err = addRecursionDetection(stack); err != nil { - return err - } if err = addRequestIDRetrieverMiddleware(stack); err != nil { return err } @@ -145,22 +131,8 @@ func (c *Client) addOperationUpdateCertificateOptionsMiddlewares(stack *middlewa 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 } - -func newServiceMetadataMiddleware_opUpdateCertificateOptions(region string) *awsmiddleware.RegisterServiceMetadata { - return &awsmiddleware.RegisterServiceMetadata{ - Region: region, - ServiceID: ServiceID, - OperationName: "UpdateCertificateOptions", - } -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/auth.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/auth.go index d91820cd2..7ab4c7af7 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/auth.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/auth.go @@ -184,7 +184,7 @@ func (m *resolveAuthSchemeMiddleware) selectScheme(options []*smithyauth.Option) } for _, scheme := range m.options.AuthSchemes { - if scheme.SchemeID() != option.SchemeID { + if !matchSchemeID(scheme.SchemeID(), option.SchemeID) { continue } @@ -197,6 +197,16 @@ func (m *resolveAuthSchemeMiddleware) selectScheme(options []*smithyauth.Option) return nil, false } +func matchSchemeID(registered, option string) bool { + if registered == option { + return true + } + if i := strings.LastIndex(registered, "#"); i != -1 { + return registered[i+1:] == option + } + return false +} + func sortAuthOptions(options []*smithyauth.Option, preferred []string) []*smithyauth.Option { byPriority := make([]*smithyauth.Option, 0, len(options)) for _, prefName := range preferred { diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/common_serde.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/common_serde.go new file mode 100644 index 000000000..af8ae5cc4 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/common_serde.go @@ -0,0 +1,1519 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" +) + +func serializeAcmCertificateMetadataFilter(s smithy.ShapeSerializer, schema *smithy.Schema, v types.AcmCertificateMetadataFilter) { + switch vv := v.(type) { + case *types.AcmCertificateMetadataFilterMemberAcmeAccountId: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_AcmeAccountId) + s.WriteString(schemas.AcmCertificateMetadataFilter_AcmeAccountId, vv.Value) + s.CloseUnion() + case *types.AcmCertificateMetadataFilterMemberAcmeEndpointArn: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_AcmeEndpointArn) + s.WriteString(schemas.AcmCertificateMetadataFilter_AcmeEndpointArn, vv.Value) + s.CloseUnion() + case *types.AcmCertificateMetadataFilterMemberCertificateKeyPairOrigin: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_CertificateKeyPairOrigin) + s.WriteString(schemas.AcmCertificateMetadataFilter_CertificateKeyPairOrigin, string(vv.Value)) + s.CloseUnion() + case *types.AcmCertificateMetadataFilterMemberExportOption: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_ExportOption) + s.WriteString(schemas.AcmCertificateMetadataFilter_ExportOption, string(vv.Value)) + s.CloseUnion() + case *types.AcmCertificateMetadataFilterMemberExported: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_Exported) + s.WriteBool(schemas.AcmCertificateMetadataFilter_Exported, vv.Value) + s.CloseUnion() + case *types.AcmCertificateMetadataFilterMemberInUse: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_InUse) + s.WriteBool(schemas.AcmCertificateMetadataFilter_InUse, vv.Value) + s.CloseUnion() + case *types.AcmCertificateMetadataFilterMemberManagedBy: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_ManagedBy) + s.WriteString(schemas.AcmCertificateMetadataFilter_ManagedBy, string(vv.Value)) + s.CloseUnion() + case *types.AcmCertificateMetadataFilterMemberRenewalStatus: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_RenewalStatus) + s.WriteString(schemas.AcmCertificateMetadataFilter_RenewalStatus, string(vv.Value)) + s.CloseUnion() + case *types.AcmCertificateMetadataFilterMemberStatus: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_Status) + s.WriteString(schemas.AcmCertificateMetadataFilter_Status, string(vv.Value)) + s.CloseUnion() + case *types.AcmCertificateMetadataFilterMemberType: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_Type) + s.WriteString(schemas.AcmCertificateMetadataFilter_Type, string(vv.Value)) + s.CloseUnion() + case *types.AcmCertificateMetadataFilterMemberValidationMethod: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_ValidationMethod) + s.WriteString(schemas.AcmCertificateMetadataFilter_ValidationMethod, string(vv.Value)) + s.CloseUnion() + } +} + +func serializeCertificateAuthority(s smithy.ShapeSerializer, schema *smithy.Schema, v types.CertificateAuthority) { + switch vv := v.(type) { + case *types.CertificateAuthorityMemberPublicCertificateAuthority: + s.WriteUnion(schema, schemas.CertificateAuthority_PublicCertificateAuthority) + s.WriteStruct(schemas.CertificateAuthority_PublicCertificateAuthority) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializeCertificateFilter(s smithy.ShapeSerializer, schema *smithy.Schema, v types.CertificateFilter) { + switch vv := v.(type) { + case *types.CertificateFilterMemberAcmCertificateMetadataFilter: + s.WriteUnion(schema, schemas.CertificateFilter_AcmCertificateMetadataFilter) + serializeAcmCertificateMetadataFilter(s, schemas.CertificateFilter_AcmCertificateMetadataFilter, vv.Value) + s.CloseUnion() + case *types.CertificateFilterMemberCertificateArn: + s.WriteUnion(schema, schemas.CertificateFilter_CertificateArn) + s.WriteString(schemas.CertificateFilter_CertificateArn, vv.Value) + s.CloseUnion() + case *types.CertificateFilterMemberX509AttributeFilter: + s.WriteUnion(schema, schemas.CertificateFilter_X509AttributeFilter) + serializeX509AttributeFilter(s, schemas.CertificateFilter_X509AttributeFilter, vv.Value) + s.CloseUnion() + } +} + +func serializeCertificateFilterStatement(s smithy.ShapeSerializer, schema *smithy.Schema, v types.CertificateFilterStatement) { + switch vv := v.(type) { + case *types.CertificateFilterStatementMemberAnd: + s.WriteUnion(schema, schemas.CertificateFilterStatement_And) + serializeCertificateFilterStatementList(s, schemas.CertificateFilterStatement_And, vv.Value) + s.CloseUnion() + case *types.CertificateFilterStatementMemberFilter: + s.WriteUnion(schema, schemas.CertificateFilterStatement_Filter) + serializeCertificateFilter(s, schemas.CertificateFilterStatement_Filter, vv.Value) + s.CloseUnion() + case *types.CertificateFilterStatementMemberNot: + s.WriteUnion(schema, schemas.CertificateFilterStatement_Not) + serializeCertificateFilterStatement(s, schemas.CertificateFilterStatement_Not, vv.Value) + s.CloseUnion() + case *types.CertificateFilterStatementMemberOr: + s.WriteUnion(schema, schemas.CertificateFilterStatement_Or) + serializeCertificateFilterStatementList(s, schemas.CertificateFilterStatement_Or, vv.Value) + s.CloseUnion() + } +} + +func serializeCertificateMetadata(s smithy.ShapeSerializer, schema *smithy.Schema, v types.CertificateMetadata) { + switch vv := v.(type) { + case *types.CertificateMetadataMemberAcmCertificateMetadata: + s.WriteUnion(schema, schemas.CertificateMetadata_AcmCertificateMetadata) + s.WriteStruct(schemas.CertificateMetadata_AcmCertificateMetadata) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializeGeneralName(s smithy.ShapeSerializer, schema *smithy.Schema, v types.GeneralName) { + switch vv := v.(type) { + case *types.GeneralNameMemberDirectoryName: + s.WriteUnion(schema, schemas.GeneralName_DirectoryName) + s.WriteStruct(schemas.GeneralName_DirectoryName) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + case *types.GeneralNameMemberDnsName: + s.WriteUnion(schema, schemas.GeneralName_DnsName) + s.WriteString(schemas.GeneralName_DnsName, vv.Value) + s.CloseUnion() + case *types.GeneralNameMemberIpAddress: + s.WriteUnion(schema, schemas.GeneralName_IpAddress) + s.WriteString(schemas.GeneralName_IpAddress, vv.Value) + s.CloseUnion() + case *types.GeneralNameMemberOtherName: + s.WriteUnion(schema, schemas.GeneralName_OtherName) + s.WriteStruct(schemas.GeneralName_OtherName) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + case *types.GeneralNameMemberRegisteredId: + s.WriteUnion(schema, schemas.GeneralName_RegisteredId) + s.WriteString(schemas.GeneralName_RegisteredId, vv.Value) + s.CloseUnion() + case *types.GeneralNameMemberRfc822Name: + s.WriteUnion(schema, schemas.GeneralName_Rfc822Name) + s.WriteString(schemas.GeneralName_Rfc822Name, vv.Value) + s.CloseUnion() + case *types.GeneralNameMemberUniformResourceIdentifier: + s.WriteUnion(schema, schemas.GeneralName_UniformResourceIdentifier) + s.WriteString(schemas.GeneralName_UniformResourceIdentifier, vv.Value) + s.CloseUnion() + } +} + +func serializePrevalidationDetails(s smithy.ShapeSerializer, schema *smithy.Schema, v types.PrevalidationDetails) { + switch vv := v.(type) { + case *types.PrevalidationDetailsMemberDnsPrevalidation: + s.WriteUnion(schema, schemas.PrevalidationDetails_DnsPrevalidation) + s.WriteStruct(schemas.PrevalidationDetails_DnsPrevalidation) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializePrevalidationOptions(s smithy.ShapeSerializer, schema *smithy.Schema, v types.PrevalidationOptions) { + switch vv := v.(type) { + case *types.PrevalidationOptionsMemberDnsPrevalidation: + s.WriteUnion(schema, schemas.PrevalidationOptions_DnsPrevalidation) + s.WriteStruct(schemas.PrevalidationOptions_DnsPrevalidation) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializeSubjectAlternativeNameFilter(s smithy.ShapeSerializer, schema *smithy.Schema, v types.SubjectAlternativeNameFilter) { + switch vv := v.(type) { + case *types.SubjectAlternativeNameFilterMemberDnsName: + s.WriteUnion(schema, schemas.SubjectAlternativeNameFilter_DnsName) + s.WriteStruct(schemas.SubjectAlternativeNameFilter_DnsName) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializeSubjectFilter(s smithy.ShapeSerializer, schema *smithy.Schema, v types.SubjectFilter) { + switch vv := v.(type) { + case *types.SubjectFilterMemberCommonName: + s.WriteUnion(schema, schemas.SubjectFilter_CommonName) + s.WriteStruct(schemas.SubjectFilter_CommonName) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializeValidationChallenge(s smithy.ShapeSerializer, schema *smithy.Schema, v types.ValidationChallenge) { + switch vv := v.(type) { + case *types.ValidationChallengeMemberDnsValidationChallenge: + s.WriteUnion(schema, schemas.ValidationChallenge_DnsValidationChallenge) + s.WriteStruct(schemas.ValidationChallenge_DnsValidationChallenge) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + case *types.ValidationChallengeMemberEmailValidationChallenge: + s.WriteUnion(schema, schemas.ValidationChallenge_EmailValidationChallenge) + s.WriteStruct(schemas.ValidationChallenge_EmailValidationChallenge) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializeX509AttributeFilter(s smithy.ShapeSerializer, schema *smithy.Schema, v types.X509AttributeFilter) { + switch vv := v.(type) { + case *types.X509AttributeFilterMemberExtendedKeyUsage: + s.WriteUnion(schema, schemas.X509AttributeFilter_ExtendedKeyUsage) + s.WriteString(schemas.X509AttributeFilter_ExtendedKeyUsage, string(vv.Value)) + s.CloseUnion() + case *types.X509AttributeFilterMemberKeyAlgorithm: + s.WriteUnion(schema, schemas.X509AttributeFilter_KeyAlgorithm) + s.WriteString(schemas.X509AttributeFilter_KeyAlgorithm, string(vv.Value)) + s.CloseUnion() + case *types.X509AttributeFilterMemberKeyUsage: + s.WriteUnion(schema, schemas.X509AttributeFilter_KeyUsage) + s.WriteString(schemas.X509AttributeFilter_KeyUsage, string(vv.Value)) + s.CloseUnion() + case *types.X509AttributeFilterMemberNotAfter: + s.WriteUnion(schema, schemas.X509AttributeFilter_NotAfter) + s.WriteStruct(schemas.X509AttributeFilter_NotAfter) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + case *types.X509AttributeFilterMemberNotBefore: + s.WriteUnion(schema, schemas.X509AttributeFilter_NotBefore) + s.WriteStruct(schemas.X509AttributeFilter_NotBefore) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + case *types.X509AttributeFilterMemberSerialNumber: + s.WriteUnion(schema, schemas.X509AttributeFilter_SerialNumber) + s.WriteString(schemas.X509AttributeFilter_SerialNumber, vv.Value) + s.CloseUnion() + case *types.X509AttributeFilterMemberSubject: + s.WriteUnion(schema, schemas.X509AttributeFilter_Subject) + serializeSubjectFilter(s, schemas.X509AttributeFilter_Subject, vv.Value) + s.CloseUnion() + case *types.X509AttributeFilterMemberSubjectAlternativeName: + s.WriteUnion(schema, schemas.X509AttributeFilter_SubjectAlternativeName) + serializeSubjectAlternativeNameFilter(s, schemas.X509AttributeFilter_SubjectAlternativeName, vv.Value) + s.CloseUnion() + } +} + +func deserializeAcmCertificateMetadataFilter(d smithy.ShapeDeserializer, s *smithy.Schema, v *types.AcmCertificateMetadataFilter) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.AcmCertificateMetadataFilter_AcmeAccountId: + vv := &types.AcmCertificateMetadataFilterMemberAcmeAccountId{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_AcmeEndpointArn: + vv := &types.AcmCertificateMetadataFilterMemberAcmeEndpointArn{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_CertificateKeyPairOrigin: + vv := &types.AcmCertificateMetadataFilterMemberCertificateKeyPairOrigin{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_ExportOption: + vv := &types.AcmCertificateMetadataFilterMemberExportOption{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_Exported: + vv := &types.AcmCertificateMetadataFilterMemberExported{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_InUse: + vv := &types.AcmCertificateMetadataFilterMemberInUse{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_ManagedBy: + vv := &types.AcmCertificateMetadataFilterMemberManagedBy{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_RenewalStatus: + vv := &types.AcmCertificateMetadataFilterMemberRenewalStatus{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_Status: + vv := &types.AcmCertificateMetadataFilterMemberStatus{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_Type: + vv := &types.AcmCertificateMetadataFilterMemberType{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_ValidationMethod: + vv := &types.AcmCertificateMetadataFilterMemberValidationMethod{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeCertificateAuthority(d smithy.ShapeDeserializer, s *smithy.Schema, v *types.CertificateAuthority) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.CertificateAuthority_PublicCertificateAuthority: + vv := &types.CertificateAuthorityMemberPublicCertificateAuthority{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeCertificateFilter(d smithy.ShapeDeserializer, s *smithy.Schema, v *types.CertificateFilter) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.CertificateFilter_AcmCertificateMetadataFilter: + vv := &types.CertificateFilterMemberAcmCertificateMetadataFilter{} + *v = vv + return vv.Deserialize(d) + case schemas.CertificateFilter_CertificateArn: + vv := &types.CertificateFilterMemberCertificateArn{} + *v = vv + return vv.Deserialize(d) + case schemas.CertificateFilter_X509AttributeFilter: + vv := &types.CertificateFilterMemberX509AttributeFilter{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeCertificateFilterStatement(d smithy.ShapeDeserializer, s *smithy.Schema, v *types.CertificateFilterStatement) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.CertificateFilterStatement_And: + vv := &types.CertificateFilterStatementMemberAnd{} + *v = vv + return vv.Deserialize(d) + case schemas.CertificateFilterStatement_Filter: + vv := &types.CertificateFilterStatementMemberFilter{} + *v = vv + return vv.Deserialize(d) + case schemas.CertificateFilterStatement_Not: + vv := &types.CertificateFilterStatementMemberNot{} + *v = vv + return vv.Deserialize(d) + case schemas.CertificateFilterStatement_Or: + vv := &types.CertificateFilterStatementMemberOr{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeCertificateMetadata(d smithy.ShapeDeserializer, s *smithy.Schema, v *types.CertificateMetadata) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.CertificateMetadata_AcmCertificateMetadata: + vv := &types.CertificateMetadataMemberAcmCertificateMetadata{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeGeneralName(d smithy.ShapeDeserializer, s *smithy.Schema, v *types.GeneralName) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.GeneralName_DirectoryName: + vv := &types.GeneralNameMemberDirectoryName{} + *v = vv + return vv.Deserialize(d) + case schemas.GeneralName_DnsName: + vv := &types.GeneralNameMemberDnsName{} + *v = vv + return vv.Deserialize(d) + case schemas.GeneralName_IpAddress: + vv := &types.GeneralNameMemberIpAddress{} + *v = vv + return vv.Deserialize(d) + case schemas.GeneralName_OtherName: + vv := &types.GeneralNameMemberOtherName{} + *v = vv + return vv.Deserialize(d) + case schemas.GeneralName_RegisteredId: + vv := &types.GeneralNameMemberRegisteredId{} + *v = vv + return vv.Deserialize(d) + case schemas.GeneralName_Rfc822Name: + vv := &types.GeneralNameMemberRfc822Name{} + *v = vv + return vv.Deserialize(d) + case schemas.GeneralName_UniformResourceIdentifier: + vv := &types.GeneralNameMemberUniformResourceIdentifier{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializePrevalidationDetails(d smithy.ShapeDeserializer, s *smithy.Schema, v *types.PrevalidationDetails) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.PrevalidationDetails_DnsPrevalidation: + vv := &types.PrevalidationDetailsMemberDnsPrevalidation{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializePrevalidationOptions(d smithy.ShapeDeserializer, s *smithy.Schema, v *types.PrevalidationOptions) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.PrevalidationOptions_DnsPrevalidation: + vv := &types.PrevalidationOptionsMemberDnsPrevalidation{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeSubjectAlternativeNameFilter(d smithy.ShapeDeserializer, s *smithy.Schema, v *types.SubjectAlternativeNameFilter) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.SubjectAlternativeNameFilter_DnsName: + vv := &types.SubjectAlternativeNameFilterMemberDnsName{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeSubjectFilter(d smithy.ShapeDeserializer, s *smithy.Schema, v *types.SubjectFilter) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.SubjectFilter_CommonName: + vv := &types.SubjectFilterMemberCommonName{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeValidationChallenge(d smithy.ShapeDeserializer, s *smithy.Schema, v *types.ValidationChallenge) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.ValidationChallenge_DnsValidationChallenge: + vv := &types.ValidationChallengeMemberDnsValidationChallenge{} + *v = vv + return vv.Deserialize(d) + case schemas.ValidationChallenge_EmailValidationChallenge: + vv := &types.ValidationChallengeMemberEmailValidationChallenge{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeX509AttributeFilter(d smithy.ShapeDeserializer, s *smithy.Schema, v *types.X509AttributeFilter) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.X509AttributeFilter_ExtendedKeyUsage: + vv := &types.X509AttributeFilterMemberExtendedKeyUsage{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_KeyAlgorithm: + vv := &types.X509AttributeFilterMemberKeyAlgorithm{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_KeyUsage: + vv := &types.X509AttributeFilterMemberKeyUsage{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_NotAfter: + vv := &types.X509AttributeFilterMemberNotAfter{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_NotBefore: + vv := &types.X509AttributeFilterMemberNotBefore{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_SerialNumber: + vv := &types.X509AttributeFilterMemberSerialNumber{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_Subject: + vv := &types.X509AttributeFilterMemberSubject{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_SubjectAlternativeName: + vv := &types.X509AttributeFilterMemberSubjectAlternativeName{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func serializeAcmeAccountList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.AcmeAccountSummary) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeAcmeDomainValidationList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.AcmeDomainValidationSummary) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeAcmeEndpointList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.AcmeEndpointSummary) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeAcmeExternalAccountBindingList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.AcmeExternalAccountBindingSummary) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeCertificateFilterStatementList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.CertificateFilterStatement) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + serializeCertificateFilterStatement(s, schema.ListMember(), vv) + } + s.CloseList() +} + +func serializeCertificateKeyPairOrigins(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.CertificateKeyPairOrigin) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeCertificateSearchResultList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.CertificateSearchResult) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeCertificateStatuses(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.CertificateStatus) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeCertificateSummaryList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.CertificateSummary) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeContactList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeCustomAttributeList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.CustomAttribute) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeDomainComponentList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeDomainList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeDomainValidationList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.DomainValidation) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeDomainValidationOptionList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.DomainValidationOption) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeDomainValidationSummaryList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.DomainValidationSummary) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeExtendedKeyUsageFilterList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.ExtendedKeyUsageName) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeExtendedKeyUsageList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.ExtendedKeyUsage) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeExtendedKeyUsageNames(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.ExtendedKeyUsageName) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeGeneralNameList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.GeneralName) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + serializeGeneralName(s, schema.ListMember(), vv) + } + s.CloseList() +} + +func serializeInUseList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeKeyAlgorithmList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.KeyAlgorithm) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeKeyUsageFilterList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.KeyUsageName) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeKeyUsageList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.KeyUsage) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeKeyUsageNames(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.KeyUsageName) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializePublicKeyAlgorithmList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.PublicKeyAlgorithm) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeTagKeyList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeTagList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.Tag) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeThrottlingReasonList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.ThrottlingReason) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeValidationEmailList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func deserializeAcmeAccountList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.AcmeAccountSummary) error { + *v = make([]types.AcmeAccountSummary, 0) + var vv types.AcmeAccountSummary + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.AcmeAccountSummary + *v = append(*v, zero) + return nil + } + + vv = types.AcmeAccountSummary{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeAcmeDomainValidationList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.AcmeDomainValidationSummary) error { + *v = make([]types.AcmeDomainValidationSummary, 0) + var vv types.AcmeDomainValidationSummary + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.AcmeDomainValidationSummary + *v = append(*v, zero) + return nil + } + + vv = types.AcmeDomainValidationSummary{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeAcmeEndpointList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.AcmeEndpointSummary) error { + *v = make([]types.AcmeEndpointSummary, 0) + var vv types.AcmeEndpointSummary + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.AcmeEndpointSummary + *v = append(*v, zero) + return nil + } + + vv = types.AcmeEndpointSummary{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeAcmeExternalAccountBindingList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.AcmeExternalAccountBindingSummary) error { + *v = make([]types.AcmeExternalAccountBindingSummary, 0) + var vv types.AcmeExternalAccountBindingSummary + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.AcmeExternalAccountBindingSummary + *v = append(*v, zero) + return nil + } + + vv = types.AcmeExternalAccountBindingSummary{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeCertificateFilterStatementList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.CertificateFilterStatement) error { + *v = make([]types.CertificateFilterStatement, 0) + var vv types.CertificateFilterStatement + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.CertificateFilterStatement + *v = append(*v, zero) + return nil + } + + if err := deserializeCertificateFilterStatement(d, s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeCertificateKeyPairOrigins(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.CertificateKeyPairOrigin) error { + *v = make([]types.CertificateKeyPairOrigin, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.CertificateKeyPairOrigin + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, types.CertificateKeyPairOrigin(vv)) + return nil + }) +} + +func deserializeCertificateSearchResultList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.CertificateSearchResult) error { + *v = make([]types.CertificateSearchResult, 0) + var vv types.CertificateSearchResult + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.CertificateSearchResult + *v = append(*v, zero) + return nil + } + + vv = types.CertificateSearchResult{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeCertificateStatuses(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.CertificateStatus) error { + *v = make([]types.CertificateStatus, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.CertificateStatus + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, types.CertificateStatus(vv)) + return nil + }) +} + +func deserializeCertificateSummaryList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.CertificateSummary) error { + *v = make([]types.CertificateSummary, 0) + var vv types.CertificateSummary + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.CertificateSummary + *v = append(*v, zero) + return nil + } + + vv = types.CertificateSummary{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeContactList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero string + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeCustomAttributeList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.CustomAttribute) error { + *v = make([]types.CustomAttribute, 0) + var vv types.CustomAttribute + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.CustomAttribute + *v = append(*v, zero) + return nil + } + + vv = types.CustomAttribute{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeDomainComponentList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero string + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeDomainList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero string + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeDomainValidationList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.DomainValidation) error { + *v = make([]types.DomainValidation, 0) + var vv types.DomainValidation + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.DomainValidation + *v = append(*v, zero) + return nil + } + + vv = types.DomainValidation{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeDomainValidationOptionList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.DomainValidationOption) error { + *v = make([]types.DomainValidationOption, 0) + var vv types.DomainValidationOption + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.DomainValidationOption + *v = append(*v, zero) + return nil + } + + vv = types.DomainValidationOption{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeDomainValidationSummaryList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.DomainValidationSummary) error { + *v = make([]types.DomainValidationSummary, 0) + var vv types.DomainValidationSummary + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.DomainValidationSummary + *v = append(*v, zero) + return nil + } + + vv = types.DomainValidationSummary{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeExtendedKeyUsageFilterList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.ExtendedKeyUsageName) error { + *v = make([]types.ExtendedKeyUsageName, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.ExtendedKeyUsageName + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, types.ExtendedKeyUsageName(vv)) + return nil + }) +} + +func deserializeExtendedKeyUsageList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.ExtendedKeyUsage) error { + *v = make([]types.ExtendedKeyUsage, 0) + var vv types.ExtendedKeyUsage + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.ExtendedKeyUsage + *v = append(*v, zero) + return nil + } + + vv = types.ExtendedKeyUsage{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeExtendedKeyUsageNames(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.ExtendedKeyUsageName) error { + *v = make([]types.ExtendedKeyUsageName, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.ExtendedKeyUsageName + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, types.ExtendedKeyUsageName(vv)) + return nil + }) +} + +func deserializeGeneralNameList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.GeneralName) error { + *v = make([]types.GeneralName, 0) + var vv types.GeneralName + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.GeneralName + *v = append(*v, zero) + return nil + } + + if err := deserializeGeneralName(d, s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeInUseList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero string + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeKeyAlgorithmList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.KeyAlgorithm) error { + *v = make([]types.KeyAlgorithm, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.KeyAlgorithm + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, types.KeyAlgorithm(vv)) + return nil + }) +} + +func deserializeKeyUsageFilterList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.KeyUsageName) error { + *v = make([]types.KeyUsageName, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.KeyUsageName + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, types.KeyUsageName(vv)) + return nil + }) +} + +func deserializeKeyUsageList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.KeyUsage) error { + *v = make([]types.KeyUsage, 0) + var vv types.KeyUsage + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.KeyUsage + *v = append(*v, zero) + return nil + } + + vv = types.KeyUsage{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeKeyUsageNames(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.KeyUsageName) error { + *v = make([]types.KeyUsageName, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.KeyUsageName + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, types.KeyUsageName(vv)) + return nil + }) +} + +func deserializePublicKeyAlgorithmList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.PublicKeyAlgorithm) error { + *v = make([]types.PublicKeyAlgorithm, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.PublicKeyAlgorithm + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, types.PublicKeyAlgorithm(vv)) + return nil + }) +} + +func deserializeTagKeyList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero string + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeTagList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.Tag) error { + *v = make([]types.Tag, 0) + var vv types.Tag + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.Tag + *v = append(*v, zero) + return nil + } + + vv = types.Tag{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeThrottlingReasonList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.ThrottlingReason) error { + *v = make([]types.ThrottlingReason, 0) + var vv types.ThrottlingReason + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero types.ThrottlingReason + *v = append(*v, zero) + return nil + } + + vv = types.ThrottlingReason{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeValidationEmailList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero string + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/deserializers.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/deserializers.go deleted file mode 100644 index 5afbedd91..000000000 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/deserializers.go +++ /dev/null @@ -1,5917 +0,0 @@ -// Code generated by smithy-go-codegen DO NOT EDIT. - -package acm - -import ( - "bytes" - "context" - "encoding/json" - "fmt" - "github.com/aws/aws-sdk-go-v2/aws/protocol/restjson" - "github.com/aws/aws-sdk-go-v2/service/acm/types" - smithy "github.com/aws/smithy-go" - smithyio "github.com/aws/smithy-go/io" - "github.com/aws/smithy-go/middleware" - "github.com/aws/smithy-go/ptr" - smithytime "github.com/aws/smithy-go/time" - "github.com/aws/smithy-go/tracing" - smithyhttp "github.com/aws/smithy-go/transport/http" - "io" - "io/ioutil" - "strings" -) - -type awsAwsjson11_deserializeOpAddTagsToCertificate struct { -} - -func (*awsAwsjson11_deserializeOpAddTagsToCertificate) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpAddTagsToCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorAddTagsToCertificate(response, &metadata) - } - output := &AddTagsToCertificateOutput{} - 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 awsAwsjson11_deserializeOpErrorAddTagsToCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("InvalidArnException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) - - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("InvalidTagException", errorCode): - return awsAwsjson11_deserializeErrorInvalidTagException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - case strings.EqualFold("TagPolicyException", errorCode): - return awsAwsjson11_deserializeErrorTagPolicyException(response, errorBody) - - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - case strings.EqualFold("TooManyTagsException", errorCode): - return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpDeleteCertificate struct { -} - -func (*awsAwsjson11_deserializeOpDeleteCertificate) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpDeleteCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCertificate(response, &metadata) - } - output := &DeleteCertificateOutput{} - 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 awsAwsjson11_deserializeOpErrorDeleteCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("AccessDeniedException", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) - - case strings.EqualFold("InvalidArnException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) - - case strings.EqualFold("ResourceInUseException", errorCode): - return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpDescribeCertificate struct { -} - -func (*awsAwsjson11_deserializeOpDescribeCertificate) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpDescribeCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCertificate(response, &metadata) - } - output := &DescribeCertificateOutput{} - out.Result = output - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentDescribeCertificateOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - return out, metadata, err -} - -func awsAwsjson11_deserializeOpErrorDescribeCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("InvalidArnException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpExportCertificate struct { -} - -func (*awsAwsjson11_deserializeOpExportCertificate) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpExportCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorExportCertificate(response, &metadata) - } - output := &ExportCertificateOutput{} - out.Result = output - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentExportCertificateOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - return out, metadata, err -} - -func awsAwsjson11_deserializeOpErrorExportCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("InvalidArnException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) - - case strings.EqualFold("RequestInProgressException", errorCode): - return awsAwsjson11_deserializeErrorRequestInProgressException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpGetAccountConfiguration struct { -} - -func (*awsAwsjson11_deserializeOpGetAccountConfiguration) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpGetAccountConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetAccountConfiguration(response, &metadata) - } - output := &GetAccountConfigurationOutput{} - out.Result = output - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentGetAccountConfigurationOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - return out, metadata, err -} - -func awsAwsjson11_deserializeOpErrorGetAccountConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("AccessDeniedException", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpGetCertificate struct { -} - -func (*awsAwsjson11_deserializeOpGetCertificate) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpGetCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetCertificate(response, &metadata) - } - output := &GetCertificateOutput{} - out.Result = output - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentGetCertificateOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - return out, metadata, err -} - -func awsAwsjson11_deserializeOpErrorGetCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("InvalidArnException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) - - case strings.EqualFold("RequestInProgressException", errorCode): - return awsAwsjson11_deserializeErrorRequestInProgressException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpImportCertificate struct { -} - -func (*awsAwsjson11_deserializeOpImportCertificate) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpImportCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorImportCertificate(response, &metadata) - } - output := &ImportCertificateOutput{} - out.Result = output - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentImportCertificateOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - return out, metadata, err -} - -func awsAwsjson11_deserializeOpErrorImportCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) - - case strings.EqualFold("InvalidArnException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) - - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("InvalidTagException", errorCode): - return awsAwsjson11_deserializeErrorInvalidTagException(response, errorBody) - - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - case strings.EqualFold("TagPolicyException", errorCode): - return awsAwsjson11_deserializeErrorTagPolicyException(response, errorBody) - - case strings.EqualFold("TooManyTagsException", errorCode): - return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpListCertificates struct { -} - -func (*awsAwsjson11_deserializeOpListCertificates) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpListCertificates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorListCertificates(response, &metadata) - } - output := &ListCertificatesOutput{} - out.Result = output - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentListCertificatesOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - return out, metadata, err -} - -func awsAwsjson11_deserializeOpErrorListCertificates(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("InvalidArgsException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArgsException(response, errorBody) - - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpListTagsForCertificate struct { -} - -func (*awsAwsjson11_deserializeOpListTagsForCertificate) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpListTagsForCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForCertificate(response, &metadata) - } - output := &ListTagsForCertificateOutput{} - out.Result = output - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentListTagsForCertificateOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - return out, metadata, err -} - -func awsAwsjson11_deserializeOpErrorListTagsForCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("InvalidArnException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpPutAccountConfiguration struct { -} - -func (*awsAwsjson11_deserializeOpPutAccountConfiguration) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpPutAccountConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorPutAccountConfiguration(response, &metadata) - } - output := &PutAccountConfigurationOutput{} - 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 awsAwsjson11_deserializeOpErrorPutAccountConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("AccessDeniedException", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) - - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpRemoveTagsFromCertificate struct { -} - -func (*awsAwsjson11_deserializeOpRemoveTagsFromCertificate) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpRemoveTagsFromCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorRemoveTagsFromCertificate(response, &metadata) - } - output := &RemoveTagsFromCertificateOutput{} - 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 awsAwsjson11_deserializeOpErrorRemoveTagsFromCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("InvalidArnException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) - - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("InvalidTagException", errorCode): - return awsAwsjson11_deserializeErrorInvalidTagException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - case strings.EqualFold("TagPolicyException", errorCode): - return awsAwsjson11_deserializeErrorTagPolicyException(response, errorBody) - - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpRenewCertificate struct { -} - -func (*awsAwsjson11_deserializeOpRenewCertificate) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpRenewCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorRenewCertificate(response, &metadata) - } - output := &RenewCertificateOutput{} - 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 awsAwsjson11_deserializeOpErrorRenewCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("InvalidArnException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) - - case strings.EqualFold("RequestInProgressException", errorCode): - return awsAwsjson11_deserializeErrorRequestInProgressException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpRequestCertificate struct { -} - -func (*awsAwsjson11_deserializeOpRequestCertificate) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpRequestCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorRequestCertificate(response, &metadata) - } - output := &RequestCertificateOutput{} - out.Result = output - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentRequestCertificateOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - return out, metadata, err -} - -func awsAwsjson11_deserializeOpErrorRequestCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("InvalidArnException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) - - case strings.EqualFold("InvalidDomainValidationOptionsException", errorCode): - return awsAwsjson11_deserializeErrorInvalidDomainValidationOptionsException(response, errorBody) - - case strings.EqualFold("InvalidParameterException", errorCode): - return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) - - case strings.EqualFold("InvalidTagException", errorCode): - return awsAwsjson11_deserializeErrorInvalidTagException(response, errorBody) - - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - - case strings.EqualFold("TagPolicyException", errorCode): - return awsAwsjson11_deserializeErrorTagPolicyException(response, errorBody) - - case strings.EqualFold("TooManyTagsException", errorCode): - return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpResendValidationEmail struct { -} - -func (*awsAwsjson11_deserializeOpResendValidationEmail) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpResendValidationEmail) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorResendValidationEmail(response, &metadata) - } - output := &ResendValidationEmailOutput{} - 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 awsAwsjson11_deserializeOpErrorResendValidationEmail(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("InvalidArnException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) - - case strings.EqualFold("InvalidDomainValidationOptionsException", errorCode): - return awsAwsjson11_deserializeErrorInvalidDomainValidationOptionsException(response, errorBody) - - case strings.EqualFold("InvalidStateException", errorCode): - return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpRevokeCertificate struct { -} - -func (*awsAwsjson11_deserializeOpRevokeCertificate) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpRevokeCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorRevokeCertificate(response, &metadata) - } - output := &RevokeCertificateOutput{} - out.Result = output - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentRevokeCertificateOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - return out, metadata, err -} - -func awsAwsjson11_deserializeOpErrorRevokeCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("AccessDeniedException", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) - - case strings.EqualFold("InvalidArnException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) - - case strings.EqualFold("ResourceInUseException", errorCode): - return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpSearchCertificates struct { -} - -func (*awsAwsjson11_deserializeOpSearchCertificates) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpSearchCertificates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorSearchCertificates(response, &metadata) - } - output := &SearchCertificatesOutput{} - out.Result = output - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(response.Body, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - err = awsAwsjson11_deserializeOpDocumentSearchCertificatesOutput(&output, shape) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return out, metadata, err - } - - return out, metadata, err -} - -func awsAwsjson11_deserializeOpErrorSearchCertificates(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("AccessDeniedException", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) - - case strings.EqualFold("ThrottlingException", errorCode): - return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) - - case strings.EqualFold("ValidationException", errorCode): - return awsAwsjson11_deserializeErrorValidationException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsjson11_deserializeOpUpdateCertificateOptions struct { -} - -func (*awsAwsjson11_deserializeOpUpdateCertificateOptions) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsjson11_deserializeOpUpdateCertificateOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - _, span := tracing.StartSpan(ctx, "OperationDeserializer") - endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") - defer endTimer() - defer span.End() - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorUpdateCertificateOptions(response, &metadata) - } - output := &UpdateCertificateOptionsOutput{} - 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 awsAwsjson11_deserializeOpErrorUpdateCertificateOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - headerCode := response.Header.Get("X-Amzn-ErrorType") - - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - bodyInfo, err := getProtocolErrorInfo(decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok { - errorCode = restjson.SanitizeErrorCode(typ) - } - if len(bodyInfo.Message) != 0 { - errorMessage = bodyInfo.Message - } - switch { - case strings.EqualFold("InvalidArnException", errorCode): - return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) - - case strings.EqualFold("InvalidStateException", errorCode): - return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody) - - case strings.EqualFold("LimitExceededException", errorCode): - return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) - - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.AccessDeniedException{} - err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.ConflictException{} - err := awsAwsjson11_deserializeDocumentConflictException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorInvalidArgsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.InvalidArgsException{} - err := awsAwsjson11_deserializeDocumentInvalidArgsException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorInvalidArnException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.InvalidArnException{} - err := awsAwsjson11_deserializeDocumentInvalidArnException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorInvalidDomainValidationOptionsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.InvalidDomainValidationOptionsException{} - err := awsAwsjson11_deserializeDocumentInvalidDomainValidationOptionsException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.InvalidParameterException{} - err := awsAwsjson11_deserializeDocumentInvalidParameterException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorInvalidStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.InvalidStateException{} - err := awsAwsjson11_deserializeDocumentInvalidStateException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorInvalidTagException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.InvalidTagException{} - err := awsAwsjson11_deserializeDocumentInvalidTagException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.LimitExceededException{} - err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorRequestInProgressException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.RequestInProgressException{} - err := awsAwsjson11_deserializeDocumentRequestInProgressException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.ResourceInUseException{} - err := awsAwsjson11_deserializeDocumentResourceInUseException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.ResourceNotFoundException{} - err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorTagPolicyException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.TagPolicyException{} - err := awsAwsjson11_deserializeDocumentTagPolicyException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.ThrottlingException{} - err := awsAwsjson11_deserializeDocumentThrottlingException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorTooManyTagsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.TooManyTagsException{} - err := awsAwsjson11_deserializeDocumentTooManyTagsException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - - body := io.TeeReader(errorBody, ringBuffer) - decoder := json.NewDecoder(body) - decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - output := &types.ValidationException{} - err := awsAwsjson11_deserializeDocumentValidationException(&output, shape) - - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - err = &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - return err - } - - errorBody.Seek(0, io.SeekStart) - return output -} - -func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.AccessDeniedException - if *v == nil { - sv = &types.AccessDeniedException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected ServiceErrorMessage to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentAcmCertificateMetadata(v **types.AcmCertificateMetadata, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.AcmCertificateMetadata - if *v == nil { - sv = &types.AcmCertificateMetadata{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "CreatedAt": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "Exported": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) - } - sv.Exported = ptr.Bool(jtv) - } - - case "ExportOption": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateExport to be of type string, got %T instead", value) - } - sv.ExportOption = types.CertificateExport(jtv) - } - - case "ImportedAt": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.ImportedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "InUse": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) - } - sv.InUse = ptr.Bool(jtv) - } - - case "IssuedAt": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.IssuedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "ManagedBy": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateManagedBy to be of type string, got %T instead", value) - } - sv.ManagedBy = types.CertificateManagedBy(jtv) - } - - case "RenewalEligibility": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected RenewalEligibility to be of type string, got %T instead", value) - } - sv.RenewalEligibility = types.RenewalEligibility(jtv) - } - - case "RenewalStatus": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected RenewalStatus to be of type string, got %T instead", value) - } - sv.RenewalStatus = types.RenewalStatus(jtv) - } - - case "RevokedAt": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.RevokedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "Status": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateStatus to be of type string, got %T instead", value) - } - sv.Status = types.CertificateStatus(jtv) - } - - case "Type": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateType to be of type string, got %T instead", value) - } - sv.Type = types.CertificateType(jtv) - } - - case "ValidationMethod": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected ValidationMethod to be of type string, got %T instead", value) - } - sv.ValidationMethod = types.ValidationMethod(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentCertificateDetail(v **types.CertificateDetail, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.CertificateDetail - if *v == nil { - sv = &types.CertificateDetail{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "CertificateArn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) - } - sv.CertificateArn = ptr.String(jtv) - } - - case "CertificateAuthorityArn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) - } - sv.CertificateAuthorityArn = ptr.String(jtv) - } - - case "CreatedAt": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "DomainName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected DomainNameString to be of type string, got %T instead", value) - } - sv.DomainName = ptr.String(jtv) - } - - case "DomainValidationOptions": - if err := awsAwsjson11_deserializeDocumentDomainValidationList(&sv.DomainValidationOptions, value); err != nil { - return err - } - - case "ExtendedKeyUsages": - if err := awsAwsjson11_deserializeDocumentExtendedKeyUsageList(&sv.ExtendedKeyUsages, value); err != nil { - return err - } - - case "FailureReason": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) - } - sv.FailureReason = types.FailureReason(jtv) - } - - case "ImportedAt": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.ImportedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "InUseBy": - if err := awsAwsjson11_deserializeDocumentInUseList(&sv.InUseBy, value); err != nil { - return err - } - - case "IssuedAt": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.IssuedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "Issuer": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Issuer = ptr.String(jtv) - } - - case "KeyAlgorithm": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected KeyAlgorithm to be of type string, got %T instead", value) - } - sv.KeyAlgorithm = types.KeyAlgorithm(jtv) - } - - case "KeyUsages": - if err := awsAwsjson11_deserializeDocumentKeyUsageList(&sv.KeyUsages, value); err != nil { - return err - } - - case "ManagedBy": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateManagedBy to be of type string, got %T instead", value) - } - sv.ManagedBy = types.CertificateManagedBy(jtv) - } - - case "NotAfter": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.NotAfter = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "NotBefore": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.NotBefore = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "Options": - if err := awsAwsjson11_deserializeDocumentCertificateOptions(&sv.Options, value); err != nil { - return err - } - - case "RenewalEligibility": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected RenewalEligibility to be of type string, got %T instead", value) - } - sv.RenewalEligibility = types.RenewalEligibility(jtv) - } - - case "RenewalSummary": - if err := awsAwsjson11_deserializeDocumentRenewalSummary(&sv.RenewalSummary, value); err != nil { - return err - } - - case "RevocationReason": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected RevocationReason to be of type string, got %T instead", value) - } - sv.RevocationReason = types.RevocationReason(jtv) - } - - case "RevokedAt": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.RevokedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "Serial": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Serial = ptr.String(jtv) - } - - case "SignatureAlgorithm": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.SignatureAlgorithm = ptr.String(jtv) - } - - case "Status": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateStatus to be of type string, got %T instead", value) - } - sv.Status = types.CertificateStatus(jtv) - } - - case "Subject": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Subject = ptr.String(jtv) - } - - case "SubjectAlternativeNames": - if err := awsAwsjson11_deserializeDocumentDomainList(&sv.SubjectAlternativeNames, value); err != nil { - return err - } - - case "Type": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateType to be of type string, got %T instead", value) - } - sv.Type = types.CertificateType(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentCertificateMetadata(v *types.CertificateMetadata, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var uv types.CertificateMetadata -loop: - for key, value := range shape { - if value == nil { - continue - } - switch key { - case "AcmCertificateMetadata": - var mv types.AcmCertificateMetadata - destAddr := &mv - if err := awsAwsjson11_deserializeDocumentAcmCertificateMetadata(&destAddr, value); err != nil { - return err - } - mv = *destAddr - uv = &types.CertificateMetadataMemberAcmCertificateMetadata{Value: mv} - break loop - - default: - uv = &types.UnknownUnionMember{Tag: key} - break loop - - } - } - *v = uv - return nil -} - -func awsAwsjson11_deserializeDocumentCertificateOptions(v **types.CertificateOptions, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.CertificateOptions - if *v == nil { - sv = &types.CertificateOptions{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "CertificateTransparencyLoggingPreference": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateTransparencyLoggingPreference to be of type string, got %T instead", value) - } - sv.CertificateTransparencyLoggingPreference = types.CertificateTransparencyLoggingPreference(jtv) - } - - case "Export": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateExport to be of type string, got %T instead", value) - } - sv.Export = types.CertificateExport(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentCertificateSearchResult(v **types.CertificateSearchResult, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.CertificateSearchResult - if *v == nil { - sv = &types.CertificateSearchResult{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "CertificateArn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) - } - sv.CertificateArn = ptr.String(jtv) - } - - case "CertificateMetadata": - if err := awsAwsjson11_deserializeDocumentCertificateMetadata(&sv.CertificateMetadata, value); err != nil { - return err - } - - case "X509Attributes": - if err := awsAwsjson11_deserializeDocumentX509Attributes(&sv.X509Attributes, value); err != nil { - return err - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentCertificateSearchResultList(v *[]types.CertificateSearchResult, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.CertificateSearchResult - if *v == nil { - cv = []types.CertificateSearchResult{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.CertificateSearchResult - destAddr := &col - if err := awsAwsjson11_deserializeDocumentCertificateSearchResult(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentCertificateSummary(v **types.CertificateSummary, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.CertificateSummary - if *v == nil { - sv = &types.CertificateSummary{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "CertificateArn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) - } - sv.CertificateArn = ptr.String(jtv) - } - - case "CreatedAt": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "DomainName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected DomainNameString to be of type string, got %T instead", value) - } - sv.DomainName = ptr.String(jtv) - } - - case "Exported": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) - } - sv.Exported = ptr.Bool(jtv) - } - - case "ExportOption": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateExport to be of type string, got %T instead", value) - } - sv.ExportOption = types.CertificateExport(jtv) - } - - case "ExtendedKeyUsages": - if err := awsAwsjson11_deserializeDocumentExtendedKeyUsageNames(&sv.ExtendedKeyUsages, value); err != nil { - return err - } - - case "HasAdditionalSubjectAlternativeNames": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) - } - sv.HasAdditionalSubjectAlternativeNames = ptr.Bool(jtv) - } - - case "ImportedAt": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.ImportedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "InUse": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) - } - sv.InUse = ptr.Bool(jtv) - } - - case "IssuedAt": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.IssuedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "KeyAlgorithm": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected KeyAlgorithm to be of type string, got %T instead", value) - } - sv.KeyAlgorithm = types.KeyAlgorithm(jtv) - } - - case "KeyUsages": - if err := awsAwsjson11_deserializeDocumentKeyUsageNames(&sv.KeyUsages, value); err != nil { - return err - } - - case "ManagedBy": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateManagedBy to be of type string, got %T instead", value) - } - sv.ManagedBy = types.CertificateManagedBy(jtv) - } - - case "NotAfter": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.NotAfter = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "NotBefore": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.NotBefore = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "RenewalEligibility": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected RenewalEligibility to be of type string, got %T instead", value) - } - sv.RenewalEligibility = types.RenewalEligibility(jtv) - } - - case "RevokedAt": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.RevokedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "Status": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateStatus to be of type string, got %T instead", value) - } - sv.Status = types.CertificateStatus(jtv) - } - - case "SubjectAlternativeNameSummaries": - if err := awsAwsjson11_deserializeDocumentDomainList(&sv.SubjectAlternativeNameSummaries, value); err != nil { - return err - } - - case "Type": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateType to be of type string, got %T instead", value) - } - sv.Type = types.CertificateType(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentCertificateSummaryList(v *[]types.CertificateSummary, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.CertificateSummary - if *v == nil { - cv = []types.CertificateSummary{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.CertificateSummary - destAddr := &col - if err := awsAwsjson11_deserializeDocumentCertificateSummary(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.ConflictException - if *v == nil { - sv = &types.ConflictException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentCustomAttribute(v **types.CustomAttribute, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.CustomAttribute - if *v == nil { - sv = &types.CustomAttribute{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "ObjectIdentifier": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.ObjectIdentifier = ptr.String(jtv) - } - - case "Value": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Value = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentCustomAttributeList(v *[]types.CustomAttribute, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.CustomAttribute - if *v == nil { - cv = []types.CustomAttribute{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.CustomAttribute - destAddr := &col - if err := awsAwsjson11_deserializeDocumentCustomAttribute(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentDistinguishedName(v **types.DistinguishedName, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.DistinguishedName - if *v == nil { - sv = &types.DistinguishedName{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "CommonName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.CommonName = ptr.String(jtv) - } - - case "Country": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Country = ptr.String(jtv) - } - - case "CustomAttributes": - if err := awsAwsjson11_deserializeDocumentCustomAttributeList(&sv.CustomAttributes, value); err != nil { - return err - } - - case "DistinguishedNameQualifier": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.DistinguishedNameQualifier = ptr.String(jtv) - } - - case "DomainComponents": - if err := awsAwsjson11_deserializeDocumentDomainComponentList(&sv.DomainComponents, value); err != nil { - return err - } - - case "GenerationQualifier": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.GenerationQualifier = ptr.String(jtv) - } - - case "GivenName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.GivenName = ptr.String(jtv) - } - - case "Initials": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Initials = ptr.String(jtv) - } - - case "Locality": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Locality = ptr.String(jtv) - } - - case "Organization": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Organization = ptr.String(jtv) - } - - case "OrganizationalUnit": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.OrganizationalUnit = ptr.String(jtv) - } - - case "Pseudonym": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Pseudonym = ptr.String(jtv) - } - - case "SerialNumber": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.SerialNumber = ptr.String(jtv) - } - - case "State": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.State = ptr.String(jtv) - } - - case "Surname": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Surname = ptr.String(jtv) - } - - case "Title": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Title = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentDomainComponentList(v *[]string, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []string - if *v == nil { - cv = []string{} - } else { - cv = *v - } - - for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - col = jtv - } - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentDomainList(v *[]string, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []string - if *v == nil { - cv = []string{} - } else { - cv = *v - } - - for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected DomainNameString to be of type string, got %T instead", value) - } - col = jtv - } - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentDomainValidation(v **types.DomainValidation, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.DomainValidation - if *v == nil { - sv = &types.DomainValidation{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "DomainName": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected DomainNameString to be of type string, got %T instead", value) - } - sv.DomainName = ptr.String(jtv) - } - - case "HttpRedirect": - if err := awsAwsjson11_deserializeDocumentHttpRedirect(&sv.HttpRedirect, value); err != nil { - return err - } - - case "ResourceRecord": - if err := awsAwsjson11_deserializeDocumentResourceRecord(&sv.ResourceRecord, value); err != nil { - return err - } - - case "ValidationDomain": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected DomainNameString to be of type string, got %T instead", value) - } - sv.ValidationDomain = ptr.String(jtv) - } - - case "ValidationEmails": - if err := awsAwsjson11_deserializeDocumentValidationEmailList(&sv.ValidationEmails, value); err != nil { - return err - } - - case "ValidationMethod": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected ValidationMethod to be of type string, got %T instead", value) - } - sv.ValidationMethod = types.ValidationMethod(jtv) - } - - case "ValidationStatus": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected DomainStatus to be of type string, got %T instead", value) - } - sv.ValidationStatus = types.DomainStatus(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentDomainValidationList(v *[]types.DomainValidation, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.DomainValidation - if *v == nil { - cv = []types.DomainValidation{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.DomainValidation - destAddr := &col - if err := awsAwsjson11_deserializeDocumentDomainValidation(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentExpiryEventsConfiguration(v **types.ExpiryEventsConfiguration, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.ExpiryEventsConfiguration - if *v == nil { - sv = &types.ExpiryEventsConfiguration{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "DaysBeforeExpiry": - if value != nil { - jtv, ok := value.(json.Number) - if !ok { - return fmt.Errorf("expected PositiveInteger to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err - } - sv.DaysBeforeExpiry = ptr.Int32(int32(i64)) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentExtendedKeyUsage(v **types.ExtendedKeyUsage, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.ExtendedKeyUsage - if *v == nil { - sv = &types.ExtendedKeyUsage{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "Name": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected ExtendedKeyUsageName to be of type string, got %T instead", value) - } - sv.Name = types.ExtendedKeyUsageName(jtv) - } - - case "OID": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.OID = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentExtendedKeyUsageList(v *[]types.ExtendedKeyUsage, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.ExtendedKeyUsage - if *v == nil { - cv = []types.ExtendedKeyUsage{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.ExtendedKeyUsage - destAddr := &col - if err := awsAwsjson11_deserializeDocumentExtendedKeyUsage(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentExtendedKeyUsageNames(v *[]types.ExtendedKeyUsageName, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.ExtendedKeyUsageName - if *v == nil { - cv = []types.ExtendedKeyUsageName{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.ExtendedKeyUsageName - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected ExtendedKeyUsageName to be of type string, got %T instead", value) - } - col = types.ExtendedKeyUsageName(jtv) - } - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentGeneralName(v *types.GeneralName, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var uv types.GeneralName -loop: - for key, value := range shape { - if value == nil { - continue - } - switch key { - case "DirectoryName": - var mv types.DistinguishedName - destAddr := &mv - if err := awsAwsjson11_deserializeDocumentDistinguishedName(&destAddr, value); err != nil { - return err - } - mv = *destAddr - uv = &types.GeneralNameMemberDirectoryName{Value: mv} - break loop - - case "DnsName": - var mv string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - mv = jtv - } - uv = &types.GeneralNameMemberDnsName{Value: mv} - break loop - - case "IpAddress": - var mv string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - mv = jtv - } - uv = &types.GeneralNameMemberIpAddress{Value: mv} - break loop - - case "OtherName": - var mv types.OtherName - destAddr := &mv - if err := awsAwsjson11_deserializeDocumentOtherName(&destAddr, value); err != nil { - return err - } - mv = *destAddr - uv = &types.GeneralNameMemberOtherName{Value: mv} - break loop - - case "RegisteredId": - var mv string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - mv = jtv - } - uv = &types.GeneralNameMemberRegisteredId{Value: mv} - break loop - - case "Rfc822Name": - var mv string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - mv = jtv - } - uv = &types.GeneralNameMemberRfc822Name{Value: mv} - break loop - - case "UniformResourceIdentifier": - var mv string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - mv = jtv - } - uv = &types.GeneralNameMemberUniformResourceIdentifier{Value: mv} - break loop - - default: - uv = &types.UnknownUnionMember{Tag: key} - break loop - - } - } - *v = uv - return nil -} - -func awsAwsjson11_deserializeDocumentGeneralNameList(v *[]types.GeneralName, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.GeneralName - if *v == nil { - cv = []types.GeneralName{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.GeneralName - if err := awsAwsjson11_deserializeDocumentGeneralName(&col, value); err != nil { - return err - } - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentHttpRedirect(v **types.HttpRedirect, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.HttpRedirect - if *v == nil { - sv = &types.HttpRedirect{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "RedirectFrom": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.RedirectFrom = ptr.String(jtv) - } - - case "RedirectTo": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.RedirectTo = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentInUseList(v *[]string, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []string - if *v == nil { - cv = []string{} - } else { - cv = *v - } - - for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - col = jtv - } - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentInvalidArgsException(v **types.InvalidArgsException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.InvalidArgsException - if *v == nil { - sv = &types.InvalidArgsException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentInvalidArnException(v **types.InvalidArnException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.InvalidArnException - if *v == nil { - sv = &types.InvalidArnException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentInvalidDomainValidationOptionsException(v **types.InvalidDomainValidationOptionsException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.InvalidDomainValidationOptionsException - if *v == nil { - sv = &types.InvalidDomainValidationOptionsException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.InvalidParameterException - if *v == nil { - sv = &types.InvalidParameterException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentInvalidStateException(v **types.InvalidStateException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.InvalidStateException - if *v == nil { - sv = &types.InvalidStateException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentInvalidTagException(v **types.InvalidTagException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.InvalidTagException - if *v == nil { - sv = &types.InvalidTagException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentKeyUsage(v **types.KeyUsage, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.KeyUsage - if *v == nil { - sv = &types.KeyUsage{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "Name": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected KeyUsageName to be of type string, got %T instead", value) - } - sv.Name = types.KeyUsageName(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentKeyUsageList(v *[]types.KeyUsage, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.KeyUsage - if *v == nil { - cv = []types.KeyUsage{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.KeyUsage - destAddr := &col - if err := awsAwsjson11_deserializeDocumentKeyUsage(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentKeyUsageNames(v *[]types.KeyUsageName, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.KeyUsageName - if *v == nil { - cv = []types.KeyUsageName{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.KeyUsageName - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected KeyUsageName to be of type string, got %T instead", value) - } - col = types.KeyUsageName(jtv) - } - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.LimitExceededException - if *v == nil { - sv = &types.LimitExceededException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentOtherName(v **types.OtherName, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.OtherName - if *v == nil { - sv = &types.OtherName{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "ObjectIdentifier": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.ObjectIdentifier = ptr.String(jtv) - } - - case "Value": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Value = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentRenewalSummary(v **types.RenewalSummary, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.RenewalSummary - if *v == nil { - sv = &types.RenewalSummary{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "DomainValidationOptions": - if err := awsAwsjson11_deserializeDocumentDomainValidationList(&sv.DomainValidationOptions, value); err != nil { - return err - } - - case "RenewalStatus": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected RenewalStatus to be of type string, got %T instead", value) - } - sv.RenewalStatus = types.RenewalStatus(jtv) - } - - case "RenewalStatusReason": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) - } - sv.RenewalStatusReason = types.FailureReason(jtv) - } - - case "UpdatedAt": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentRequestInProgressException(v **types.RequestInProgressException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.RequestInProgressException - if *v == nil { - sv = &types.RequestInProgressException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.ResourceInUseException - if *v == nil { - sv = &types.ResourceInUseException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.ResourceNotFoundException - if *v == nil { - sv = &types.ResourceNotFoundException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentResourceRecord(v **types.ResourceRecord, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.ResourceRecord - if *v == nil { - sv = &types.ResourceRecord{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "Name": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Name = ptr.String(jtv) - } - - case "Type": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected RecordType to be of type string, got %T instead", value) - } - sv.Type = types.RecordType(jtv) - } - - case "Value": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Value = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.Tag - if *v == nil { - sv = &types.Tag{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "Key": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) - } - sv.Key = ptr.String(jtv) - } - - case "Value": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) - } - sv.Value = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.Tag - if *v == nil { - cv = []types.Tag{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.Tag - destAddr := &col - if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentTagPolicyException(v **types.TagPolicyException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.TagPolicyException - if *v == nil { - sv = &types.TagPolicyException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.ThrottlingException - if *v == nil { - sv = &types.ThrottlingException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected AvailabilityErrorMessage to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - case "throttlingReasons": - if err := awsAwsjson11_deserializeDocumentThrottlingReasonList(&sv.ThrottlingReasons, value); err != nil { - return err - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentThrottlingReason(v **types.ThrottlingReason, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.ThrottlingReason - if *v == nil { - sv = &types.ThrottlingReason{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "reason": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CoralAvailabilityThrottlingReason to be of type string, got %T instead", value) - } - sv.Reason = ptr.String(jtv) - } - - case "resource": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CoralAvailabilityThrottledResource to be of type string, got %T instead", value) - } - sv.Resource = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentThrottlingReasonList(v *[]types.ThrottlingReason, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []types.ThrottlingReason - if *v == nil { - cv = []types.ThrottlingReason{} - } else { - cv = *v - } - - for _, value := range shape { - var col types.ThrottlingReason - destAddr := &col - if err := awsAwsjson11_deserializeDocumentThrottlingReason(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentTooManyTagsException(v **types.TooManyTagsException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.TooManyTagsException - if *v == nil { - sv = &types.TooManyTagsException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentValidationEmailList(v *[]string, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var cv []string - if *v == nil { - cv = []string{} - } else { - cv = *v - } - - for _, value := range shape { - var col string - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) - } - col = jtv - } - cv = append(cv, col) - - } - *v = cv - return nil -} - -func awsAwsjson11_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.ValidationException - if *v == nil { - sv = &types.ValidationException{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "message", "Message": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected ValidationExceptionMessage to be of type string, got %T instead", value) - } - sv.Message = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeDocumentX509Attributes(v **types.X509Attributes, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *types.X509Attributes - if *v == nil { - sv = &types.X509Attributes{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "ExtendedKeyUsages": - if err := awsAwsjson11_deserializeDocumentExtendedKeyUsageNames(&sv.ExtendedKeyUsages, value); err != nil { - return err - } - - case "Issuer": - if err := awsAwsjson11_deserializeDocumentDistinguishedName(&sv.Issuer, value); err != nil { - return err - } - - case "KeyAlgorithm": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected KeyAlgorithm to be of type string, got %T instead", value) - } - sv.KeyAlgorithm = types.KeyAlgorithm(jtv) - } - - case "KeyUsages": - if err := awsAwsjson11_deserializeDocumentKeyUsageNames(&sv.KeyUsages, value); err != nil { - return err - } - - case "NotAfter": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.NotAfter = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "NotBefore": - if value != nil { - switch jtv := value.(type) { - case json.Number: - f64, err := jtv.Float64() - if err != nil { - return err - } - sv.NotBefore = ptr.Time(smithytime.ParseEpochSeconds(f64)) - - default: - return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - - } - } - - case "SerialNumber": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected SerialNumber to be of type string, got %T instead", value) - } - sv.SerialNumber = ptr.String(jtv) - } - - case "Subject": - if err := awsAwsjson11_deserializeDocumentDistinguishedName(&sv.Subject, value); err != nil { - return err - } - - case "SubjectAlternativeNames": - if err := awsAwsjson11_deserializeDocumentGeneralNameList(&sv.SubjectAlternativeNames, value); err != nil { - return err - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeOpDocumentDescribeCertificateOutput(v **DescribeCertificateOutput, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *DescribeCertificateOutput - if *v == nil { - sv = &DescribeCertificateOutput{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "Certificate": - if err := awsAwsjson11_deserializeDocumentCertificateDetail(&sv.Certificate, value); err != nil { - return err - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeOpDocumentExportCertificateOutput(v **ExportCertificateOutput, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *ExportCertificateOutput - if *v == nil { - sv = &ExportCertificateOutput{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "Certificate": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateBody to be of type string, got %T instead", value) - } - sv.Certificate = ptr.String(jtv) - } - - case "CertificateChain": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateChain to be of type string, got %T instead", value) - } - sv.CertificateChain = ptr.String(jtv) - } - - case "PrivateKey": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected PrivateKey to be of type string, got %T instead", value) - } - sv.PrivateKey = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeOpDocumentGetAccountConfigurationOutput(v **GetAccountConfigurationOutput, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *GetAccountConfigurationOutput - if *v == nil { - sv = &GetAccountConfigurationOutput{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "ExpiryEvents": - if err := awsAwsjson11_deserializeDocumentExpiryEventsConfiguration(&sv.ExpiryEvents, value); err != nil { - return err - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeOpDocumentGetCertificateOutput(v **GetCertificateOutput, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *GetCertificateOutput - if *v == nil { - sv = &GetCertificateOutput{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "Certificate": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateBody to be of type string, got %T instead", value) - } - sv.Certificate = ptr.String(jtv) - } - - case "CertificateChain": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected CertificateChain to be of type string, got %T instead", value) - } - sv.CertificateChain = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeOpDocumentImportCertificateOutput(v **ImportCertificateOutput, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *ImportCertificateOutput - if *v == nil { - sv = &ImportCertificateOutput{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "CertificateArn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) - } - sv.CertificateArn = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeOpDocumentListCertificatesOutput(v **ListCertificatesOutput, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *ListCertificatesOutput - if *v == nil { - sv = &ListCertificatesOutput{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "CertificateSummaryList": - if err := awsAwsjson11_deserializeDocumentCertificateSummaryList(&sv.CertificateSummaryList, value); err != nil { - return err - } - - case "NextToken": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) - } - sv.NextToken = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeOpDocumentListTagsForCertificateOutput(v **ListTagsForCertificateOutput, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *ListTagsForCertificateOutput - if *v == nil { - sv = &ListTagsForCertificateOutput{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "Tags": - if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { - return err - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeOpDocumentRequestCertificateOutput(v **RequestCertificateOutput, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *RequestCertificateOutput - if *v == nil { - sv = &RequestCertificateOutput{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "CertificateArn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) - } - sv.CertificateArn = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeOpDocumentRevokeCertificateOutput(v **RevokeCertificateOutput, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *RevokeCertificateOutput - if *v == nil { - sv = &RevokeCertificateOutput{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "CertificateArn": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected Arn to be of type string, got %T instead", value) - } - sv.CertificateArn = ptr.String(jtv) - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -func awsAwsjson11_deserializeOpDocumentSearchCertificatesOutput(v **SearchCertificatesOutput, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } - - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } - - var sv *SearchCertificatesOutput - if *v == nil { - sv = &SearchCertificatesOutput{} - } else { - sv = *v - } - - for key, value := range shape { - switch key { - case "NextToken": - if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) - } - sv.NextToken = ptr.String(jtv) - } - - case "Results": - if err := awsAwsjson11_deserializeDocumentCertificateSearchResultList(&sv.Results, value); err != nil { - return err - } - - default: - _, _ = key, value - - } - } - *v = sv - return nil -} - -type protocolErrorInfo struct { - Type string `json:"__type"` - Message string - Code any // nonstandard for awsjson but some services do present the type here -} - -func getProtocolErrorInfo(decoder *json.Decoder) (protocolErrorInfo, error) { - var errInfo protocolErrorInfo - if err := decoder.Decode(&errInfo); err != nil { - if err == io.EOF { - return errInfo, nil - } - return errInfo, err - } - - return errInfo, nil -} - -func resolveProtocolErrorType(headerType string, bodyInfo protocolErrorInfo) (string, bool) { - if len(headerType) != 0 { - return headerType, true - } else if len(bodyInfo.Type) != 0 { - return bodyInfo.Type, true - } else if code, ok := bodyInfo.Code.(string); ok && len(code) != 0 { - return code, true - } - return "", false -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/endpoints.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/endpoints.go index 76763aba3..eddbcf0a0 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/endpoints.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/endpoints.go @@ -14,6 +14,7 @@ import ( internalendpoints "github.com/aws/aws-sdk-go-v2/service/acm/internal/endpoints" smithyauth "github.com/aws/smithy-go/auth" smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/endpoints/private/bdd" "github.com/aws/smithy-go/endpoints/private/rulesfn" "github.com/aws/smithy-go/middleware" "github.com/aws/smithy-go/ptr" @@ -229,47 +230,53 @@ func bindRegion(region string) (*string, error) { return aws.String(endpoints.MapFIPSRegion(region)), nil } +var _ = rulesfn.StringSlice(nil) + // EndpointParameters provides the parameters that influence how endpoints are // resolved. type EndpointParameters struct { - // The AWS region used to dispatch the request. - // - // Parameter is - // required. + // The AWS region to send requests to. // // AWS::Region Region *string - // When true, use the dual-stack endpoint. If the configured endpoint does not - // support dual-stack, dispatching the request MAY return an error. + // Override the endpoint used to send requests. // - // Defaults to - // false if no value is provided. + // Parameter is + // required. // - // AWS::UseDualStack - UseDualStack *bool + // SDK::Endpoint + Endpoint *string - // When true, send this request to the FIPS-compliant regional endpoint. If the - // configured endpoint does not have a FIPS compliant endpoint, dispatching the - // request will return an error. + // Use FIPS endpoints. // - // Defaults to false if no value is - // provided. + // Defaults to false if no value is provided. // // AWS::UseFIPS UseFIPS *bool - // Override the endpoint used to send this request + // Use dual-stack endpoints. // - // Parameter is - // required. + // Defaults to false if no value is + // provided. // - // SDK::Endpoint - Endpoint *string + // AWS::UseDualStack + UseDualStack *bool + + // The service type: ACM or ACM-ACME. Injected via @staticContextParams. + ServiceType *string } // ValidateRequired validates required parameters are set. func (p EndpointParameters) ValidateRequired() error { + if p.Region == nil { + return fmt.Errorf("parameter Region is required") + } + + if p.ServiceType == nil { + return fmt.Errorf("parameter ServiceType is required") + } + if p.UseDualStack == nil { return fmt.Errorf("parameter UseDualStack is required") } @@ -294,21 +301,166 @@ func (p EndpointParameters) WithDefaults() EndpointParameters { return p } -type stringSlice []string +const bddRoot int32 = 2 -func (s stringSlice) Get(i int) *string { - if i < 0 || i >= len(s) { - return nil - } +var bddNodes = [30]int32{ + -1, 1, -1, 0, 100000001, 3, 1, 4, 100000010, 2, 9, 5, 4, 7, 6, 5, 100000008, 100000009, 5, 100000005, 8, 6, 100000006, 100000007, 3, 10, 100000004, 4, 100000002, 100000003} - v := s[i] - return &v +type conditionContext struct { + PartitionResult *awsrulesfn.PartitionConfig +} + +func evalCondition(idx int, params *EndpointParameters, c *conditionContext) bool { + switch idx { + case 0: + return params.Endpoint != nil + case 1: + if v := awsrulesfn.GetPartition(*params.Region); v != nil { + c.PartitionResult = v + return true + } + return false + case 2: + return *params.ServiceType == "ACM-ACME" + case 3: + return c.PartitionResult.Name == "aws" + case 4: + return *params.UseFIPS == true + case 5: + return *params.UseDualStack == true + case 6: + return c.PartitionResult.Name == "aws-us-gov" + } + return false +} + +func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (smithyendpoints.Endpoint, error) { + switch idx { + case 0: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint resolution failed: no matching rule") + case 1: + uriString := *params.Endpoint + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 2: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS endpoints are not available for ACME operations") + case 3: + uriString := func() string { + var out strings.Builder + out.WriteString("https://acm-acme.") + out.WriteString(*params.Region) + out.WriteString(".") + out.WriteString(c.PartitionResult.DualStackDnsSuffix) + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 4: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "ACME operations are only available in commercial AWS partitions") + case 5: + uriString := func() string { + var out strings.Builder + out.WriteString("https://acm-fips.") + out.WriteString(*params.Region) + out.WriteString(".") + out.WriteString(c.PartitionResult.DualStackDnsSuffix) + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 6: + uriString := func() string { + var out strings.Builder + out.WriteString("https://acm.") + out.WriteString(*params.Region) + out.WriteString(".amazonaws.com") + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 7: + uriString := func() string { + var out strings.Builder + out.WriteString("https://acm-fips.") + out.WriteString(*params.Region) + out.WriteString(".") + out.WriteString(c.PartitionResult.DnsSuffix) + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 8: + uriString := func() string { + var out strings.Builder + out.WriteString("https://acm.") + out.WriteString(*params.Region) + out.WriteString(".") + out.WriteString(c.PartitionResult.DualStackDnsSuffix) + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 9: + uriString := func() string { + var out strings.Builder + out.WriteString("https://acm.") + out.WriteString(*params.Region) + out.WriteString(".") + out.WriteString(c.PartitionResult.DnsSuffix) + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 10: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Region must be set to resolve an endpoint.") + } + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, invalid result index: %d", idx) } // EndpointResolverV2 provides the interface for resolving service endpoints. type EndpointResolverV2 interface { - // ResolveEndpoint attempts to resolve the endpoint with the provided options, - // returning the endpoint if found. Otherwise an error is returned. ResolveEndpoint(ctx context.Context, params EndpointParameters) ( smithyendpoints.Endpoint, error, ) @@ -332,152 +484,12 @@ func (r *resolver) ResolveEndpoint( if err = params.ValidateRequired(); err != nil { return endpoint, fmt.Errorf("endpoint parameters are not valid, %w", err) } - _UseDualStack := *params.UseDualStack - _ = _UseDualStack - _UseFIPS := *params.UseFIPS - _ = _UseFIPS - - if exprVal := params.Endpoint; exprVal != nil { - _Endpoint := *exprVal - _ = _Endpoint - if _UseFIPS == true { - return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: FIPS and custom endpoint are not supported") - } - if _UseDualStack == true { - return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Dualstack and custom endpoint are not supported") - } - uriString := _Endpoint - - uri, err := url.Parse(uriString) - if err != nil { - return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString) - } - - return smithyendpoints.Endpoint{ - URI: *uri, - Headers: http.Header{}, - }, nil - } - if exprVal := params.Region; exprVal != nil { - _Region := *exprVal - _ = _Region - if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil { - _PartitionResult := *exprVal - _ = _PartitionResult - if _UseFIPS == true { - if _UseDualStack == true { - if true == _PartitionResult.SupportsFIPS { - if true == _PartitionResult.SupportsDualStack { - uriString := func() string { - var out strings.Builder - out.WriteString("https://acm-fips.") - out.WriteString(_Region) - out.WriteString(".") - out.WriteString(_PartitionResult.DualStackDnsSuffix) - return out.String() - }() - - uri, err := url.Parse(uriString) - if err != nil { - return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString) - } - - return smithyendpoints.Endpoint{ - URI: *uri, - Headers: http.Header{}, - }, nil - } - } - return endpoint, fmt.Errorf("endpoint rule error, %s", "FIPS and DualStack are enabled, but this partition does not support one or both") - } - } - if _UseFIPS == true { - if _PartitionResult.SupportsFIPS == true { - if _PartitionResult.Name == "aws-us-gov" { - uriString := func() string { - var out strings.Builder - out.WriteString("https://acm.") - out.WriteString(_Region) - out.WriteString(".amazonaws.com") - return out.String() - }() - - uri, err := url.Parse(uriString) - if err != nil { - return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString) - } - - return smithyendpoints.Endpoint{ - URI: *uri, - Headers: http.Header{}, - }, nil - } - uriString := func() string { - var out strings.Builder - out.WriteString("https://acm-fips.") - out.WriteString(_Region) - out.WriteString(".") - out.WriteString(_PartitionResult.DnsSuffix) - return out.String() - }() - - uri, err := url.Parse(uriString) - if err != nil { - return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString) - } - - return smithyendpoints.Endpoint{ - URI: *uri, - Headers: http.Header{}, - }, nil - } - return endpoint, fmt.Errorf("endpoint rule error, %s", "FIPS is enabled but this partition does not support FIPS") - } - if _UseDualStack == true { - if true == _PartitionResult.SupportsDualStack { - uriString := func() string { - var out strings.Builder - out.WriteString("https://acm.") - out.WriteString(_Region) - out.WriteString(".") - out.WriteString(_PartitionResult.DualStackDnsSuffix) - return out.String() - }() - - uri, err := url.Parse(uriString) - if err != nil { - return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString) - } - - return smithyendpoints.Endpoint{ - URI: *uri, - Headers: http.Header{}, - }, nil - } - return endpoint, fmt.Errorf("endpoint rule error, %s", "DualStack is enabled but this partition does not support DualStack") - } - uriString := func() string { - var out strings.Builder - out.WriteString("https://acm.") - out.WriteString(_Region) - out.WriteString(".") - out.WriteString(_PartitionResult.DnsSuffix) - return out.String() - }() - - uri, err := url.Parse(uriString) - if err != nil { - return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString) - } - return smithyendpoints.Endpoint{ - URI: *uri, - Headers: http.Header{}, - }, nil - } - return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.") - } - return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Missing Region") + c := &conditionContext{} + ref := bdd.Evaluate(bddNodes[:], bddRoot, func(idx int) bool { + return evalCondition(idx, ¶ms, c) + }) + return resolveResult(ref, ¶ms, c) } type endpointParamsBinder interface { @@ -493,9 +505,11 @@ func bindEndpointParams(ctx context.Context, input interface{}, options Options) } params.Region = region - params.UseDualStack = aws.Bool(options.EndpointOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled) - params.UseFIPS = aws.Bool(options.EndpointOptions.UseFIPSEndpoint == aws.FIPSEndpointStateEnabled) params.Endpoint = options.BaseEndpoint + params.UseFIPS = aws.Bool(options.EndpointOptions.UseFIPSEndpoint == aws.FIPSEndpointStateEnabled) + params.UseDualStack = aws.Bool(options.EndpointOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled) + + params.ServiceType = options.ServiceType if b, ok := input.(endpointParamsBinder); ok { b.bindEndpointParams(params) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/generated.json b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/generated.json index 077086386..546a54c41 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/generated.json +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/generated.json @@ -9,24 +9,47 @@ "api_client.go", "api_client_test.go", "api_op_AddTagsToCertificate.go", + "api_op_CreateAcmeDomainValidation.go", + "api_op_CreateAcmeEndpoint.go", + "api_op_CreateAcmeExternalAccountBinding.go", + "api_op_DeleteAcmeDomainValidation.go", + "api_op_DeleteAcmeEndpoint.go", + "api_op_DeleteAcmeExternalAccountBinding.go", "api_op_DeleteCertificate.go", + "api_op_DescribeAcmeAccount.go", + "api_op_DescribeAcmeDomainValidation.go", + "api_op_DescribeAcmeEndpoint.go", + "api_op_DescribeAcmeExternalAccountBinding.go", "api_op_DescribeCertificate.go", "api_op_ExportCertificate.go", "api_op_GetAccountConfiguration.go", + "api_op_GetAcmeExternalAccountBindingCredentials.go", "api_op_GetCertificate.go", "api_op_ImportCertificate.go", + "api_op_ListAcmeAccounts.go", + "api_op_ListAcmeDomainValidations.go", + "api_op_ListAcmeEndpoints.go", + "api_op_ListAcmeExternalAccountBindings.go", + "api_op_ListCertificateDomainValidations.go", "api_op_ListCertificates.go", "api_op_ListTagsForCertificate.go", + "api_op_ListTagsForResource.go", "api_op_PutAccountConfiguration.go", "api_op_RemoveTagsFromCertificate.go", "api_op_RenewCertificate.go", "api_op_RequestCertificate.go", "api_op_ResendValidationEmail.go", + "api_op_RevokeAcmeAccount.go", + "api_op_RevokeAcmeExternalAccountBinding.go", "api_op_RevokeCertificate.go", "api_op_SearchCertificates.go", + "api_op_TagResource.go", + "api_op_UntagResource.go", + "api_op_UpdateAcmeDomainValidation.go", + "api_op_UpdateAcmeEndpoint.go", "api_op_UpdateCertificateOptions.go", "auth.go", - "deserializers.go", + "common_serde.go", "doc.go", "endpoints.go", "endpoints_config_test.go", @@ -35,9 +58,14 @@ "internal/endpoints/endpoints.go", "internal/endpoints/endpoints_test.go", "options.go", - "serializers.go", + "request_snapshot_test.go", + "response_snapshot_test.go", + "response_snapshot_update_test.go", + "schemas/schemas.go", "snapshot_test.go", "sra_operation_order_test.go", + "type_registry.go", + "types/common_serde.go", "types/enums.go", "types/errors.go", "types/types.go", diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/go_module_metadata.go index 36a743a99..84563f509 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/go_module_metadata.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/go_module_metadata.go @@ -3,4 +3,4 @@ package acm // goModuleVersion is the tagged release for this module -const goModuleVersion = "1.38.3" +const goModuleVersion = "1.50.6" diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/options.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/options.go index 7e1e68f0a..259687484 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/options.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/options.go @@ -44,6 +44,11 @@ type Options struct { // clients initial default settings. DefaultsMode aws.DefaultsMode + // Disables SDK clock skew correction. When set, the SDK will not adjust request + // signing timestamps to compensate for clock drift between the client and the + // service. + DisableClockSkewCorrection bool + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -64,6 +69,10 @@ type Options struct { // Signature Version 4 (SigV4) Signer HTTPSignerV4 HTTPSignerV4 + // Provides idempotency tokens values that will be automatically populated into + // idempotent API operations. + IdempotencyTokenProvider IdempotencyTokenProvider + // The logger writer interface to write logging messages to. Logger logging.Logger @@ -104,6 +113,9 @@ type Options struct { // within your applications. RuntimeEnvironment aws.RuntimeEnvironment + // The service type: ACM or ACM-ACME. Injected via @staticContextParams. + ServiceType *string + // The client tracer provider. TracerProvider tracing.TracerProvider @@ -114,6 +126,8 @@ type Options struct { // Currently does not support per operation call overrides, may in the future. resolvedDefaultsMode aws.DefaultsMode + Protocol smithyhttp.ClientProtocol + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/schemas/schemas.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/schemas/schemas.go new file mode 100644 index 000000000..3c07eb4bd --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/schemas/schemas.go @@ -0,0 +1,3658 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package schemas + +import ( + smithy "github.com/aws/smithy-go" + smithyprelude "github.com/aws/smithy-go/prelude" + smithytraits "github.com/aws/smithy-go/traits" +) + +var AddTagsToCertificate = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AddTagsToCertificate", +}, smithy.ShapeTypeOperation, 0) + +var CreateAcmeDomainValidation = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CreateAcmeDomainValidation", +}, smithy.ShapeTypeOperation, 0) + +var CreateAcmeEndpoint = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CreateAcmeEndpoint", +}, smithy.ShapeTypeOperation, 0) + +var CreateAcmeExternalAccountBinding = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CreateAcmeExternalAccountBinding", +}, smithy.ShapeTypeOperation, 0) + +var DeleteAcmeDomainValidation = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DeleteAcmeDomainValidation", +}, smithy.ShapeTypeOperation, 0) + +var DeleteAcmeEndpoint = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DeleteAcmeEndpoint", +}, smithy.ShapeTypeOperation, 0) + +var DeleteAcmeExternalAccountBinding = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DeleteAcmeExternalAccountBinding", +}, smithy.ShapeTypeOperation, 0) + +var DeleteCertificate = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DeleteCertificate", +}, smithy.ShapeTypeOperation, 0) + +var DescribeAcmeAccount = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeAcmeAccount", +}, smithy.ShapeTypeOperation, 0) + +var DescribeAcmeDomainValidation = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeAcmeDomainValidation", +}, smithy.ShapeTypeOperation, 0) + +var DescribeAcmeEndpoint = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeAcmeEndpoint", +}, smithy.ShapeTypeOperation, 0) + +var DescribeAcmeExternalAccountBinding = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeAcmeExternalAccountBinding", +}, smithy.ShapeTypeOperation, 0) + +var DescribeCertificate = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeCertificate", +}, smithy.ShapeTypeOperation, 0) + +var ExportCertificate = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ExportCertificate", +}, smithy.ShapeTypeOperation, 0) + +var GetAccountConfiguration = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "GetAccountConfiguration", +}, smithy.ShapeTypeOperation, 0) + +var GetAcmeExternalAccountBindingCredentials = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "GetAcmeExternalAccountBindingCredentials", +}, smithy.ShapeTypeOperation, 0) + +var GetCertificate = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "GetCertificate", +}, smithy.ShapeTypeOperation, 0) + +var ImportCertificate = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ImportCertificate", +}, smithy.ShapeTypeOperation, 0) + +var ListAcmeAccounts = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListAcmeAccounts", +}, smithy.ShapeTypeOperation, 0) + +var ListAcmeDomainValidations = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListAcmeDomainValidations", +}, smithy.ShapeTypeOperation, 0) + +var ListAcmeEndpoints = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListAcmeEndpoints", +}, smithy.ShapeTypeOperation, 0) + +var ListAcmeExternalAccountBindings = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListAcmeExternalAccountBindings", +}, smithy.ShapeTypeOperation, 0) + +var ListCertificateDomainValidations = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListCertificateDomainValidations", +}, smithy.ShapeTypeOperation, 0) + +var ListCertificates = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListCertificates", +}, smithy.ShapeTypeOperation, 0) + +var ListTagsForCertificate = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListTagsForCertificate", +}, smithy.ShapeTypeOperation, 0) + +var ListTagsForResource = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListTagsForResource", +}, smithy.ShapeTypeOperation, 0) + +var PutAccountConfiguration = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "PutAccountConfiguration", +}, smithy.ShapeTypeOperation, 0) + +var RemoveTagsFromCertificate = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RemoveTagsFromCertificate", +}, smithy.ShapeTypeOperation, 0) + +var RenewCertificate = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RenewCertificate", +}, smithy.ShapeTypeOperation, 0) + +var RequestCertificate = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RequestCertificate", +}, smithy.ShapeTypeOperation, 0) + +var ResendValidationEmail = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ResendValidationEmail", +}, smithy.ShapeTypeOperation, 0) + +var RevokeAcmeAccount = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RevokeAcmeAccount", +}, smithy.ShapeTypeOperation, 0) + +var RevokeAcmeExternalAccountBinding = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RevokeAcmeExternalAccountBinding", +}, smithy.ShapeTypeOperation, 0) + +var RevokeCertificate = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RevokeCertificate", +}, smithy.ShapeTypeOperation, 0) + +var SearchCertificates = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "SearchCertificates", +}, smithy.ShapeTypeOperation, 0) + +var TagResource = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "TagResource", +}, smithy.ShapeTypeOperation, 0) + +var UntagResource = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "UntagResource", +}, smithy.ShapeTypeOperation, 0) + +var UpdateAcmeDomainValidation = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "UpdateAcmeDomainValidation", +}, smithy.ShapeTypeOperation, 0) + +var UpdateAcmeEndpoint = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "UpdateAcmeEndpoint", +}, smithy.ShapeTypeOperation, 0) + +var UpdateCertificateOptions = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "UpdateCertificateOptions", +}, smithy.ShapeTypeOperation, 0) + +var _CertificateManager = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateManager", +}, smithy.ShapeTypeService, 0) + +var CertificateManager = smithy.NewServiceSchema(_CertificateManager, "2015-12-08") + +var AccessDeniedException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AccessDeniedException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}, + &smithytraits.HTTPError{Code: 403}, + &smithytraits.AWSQueryError{ErrorCode: "AccessDenied", + StatusCode: 403}) +var AccessDeniedException_Message *smithy.Schema + +var AcmCertificateMetadata = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmCertificateMetadata", +}, smithy.ShapeTypeStructure, 16) +var AcmCertificateMetadata_CreatedAt *smithy.Schema + +var AcmCertificateMetadata_Exported *smithy.Schema + +var AcmCertificateMetadata_ImportedAt *smithy.Schema + +var AcmCertificateMetadata_InUse *smithy.Schema + +var AcmCertificateMetadata_IssuedAt *smithy.Schema + +var AcmCertificateMetadata_RenewalEligibility *smithy.Schema + +var AcmCertificateMetadata_RevokedAt *smithy.Schema + +var AcmCertificateMetadata_Status *smithy.Schema + +var AcmCertificateMetadata_RenewalStatus *smithy.Schema + +var AcmCertificateMetadata_Type *smithy.Schema + +var AcmCertificateMetadata_ExportOption *smithy.Schema + +var AcmCertificateMetadata_ManagedBy *smithy.Schema + +var AcmCertificateMetadata_ValidationMethod *smithy.Schema + +var AcmCertificateMetadata_CertificateKeyPairOrigin *smithy.Schema + +var AcmCertificateMetadata_AcmeEndpointArn *smithy.Schema + +var AcmCertificateMetadata_AcmeAccountId *smithy.Schema + +var AcmCertificateMetadataFilter = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmCertificateMetadataFilter", +}, smithy.ShapeTypeUnion, 11) +var AcmCertificateMetadataFilter_Status *smithy.Schema + +var AcmCertificateMetadataFilter_RenewalStatus *smithy.Schema + +var AcmCertificateMetadataFilter_Type *smithy.Schema + +var AcmCertificateMetadataFilter_InUse *smithy.Schema + +var AcmCertificateMetadataFilter_Exported *smithy.Schema + +var AcmCertificateMetadataFilter_ExportOption *smithy.Schema + +var AcmCertificateMetadataFilter_ManagedBy *smithy.Schema + +var AcmCertificateMetadataFilter_ValidationMethod *smithy.Schema + +var AcmCertificateMetadataFilter_CertificateKeyPairOrigin *smithy.Schema + +var AcmCertificateMetadataFilter_AcmeEndpointArn *smithy.Schema + +var AcmCertificateMetadataFilter_AcmeAccountId *smithy.Schema + +var AcmeAccount = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeAccount", +}, smithy.ShapeTypeStructure, 6) +var AcmeAccount_AccountUrl *smithy.Schema + +var AcmeAccount_PublicKeyThumbprint *smithy.Schema + +var AcmeAccount_Status *smithy.Schema + +var AcmeAccount_CreatedAt *smithy.Schema + +var AcmeAccount_AcmeExternalAccountBindingArn *smithy.Schema + +var AcmeAccount_Contacts *smithy.Schema + +var _AcmeAccountId = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeAccountId", +}, smithy.ShapeTypeString, 0) + +var _AcmeAccountList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeAccountList", +}, smithy.ShapeTypeList, 1) +var _AcmeAccountList_member *smithy.Schema + +var AcmeAccountStatus = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeAccountStatus", +}, smithy.ShapeTypeEnum, 3) +var AcmeAccountStatus_VALID *smithy.Schema + +var AcmeAccountStatus_DEACTIVATED *smithy.Schema + +var AcmeAccountStatus_REVOKED *smithy.Schema + +var AcmeAccountSummary = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeAccountSummary", +}, smithy.ShapeTypeStructure, 6) +var AcmeAccountSummary_AccountUrl *smithy.Schema + +var AcmeAccountSummary_PublicKeyThumbprint *smithy.Schema + +var AcmeAccountSummary_Status *smithy.Schema + +var AcmeAccountSummary_CreatedAt *smithy.Schema + +var AcmeAccountSummary_AcmeExternalAccountBindingArn *smithy.Schema + +var AcmeAccountSummary_Contacts *smithy.Schema + +var AcmeAuthorizationBehavior = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeAuthorizationBehavior", +}, smithy.ShapeTypeEnum, 1) +var AcmeAuthorizationBehavior_PRE_APPROVED *smithy.Schema + +var AcmeContact = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeContact", +}, smithy.ShapeTypeEnum, 2) +var AcmeContact_REQUIRED *smithy.Schema + +var AcmeContact_NOT_REQUIRED *smithy.Schema + +var AcmeDomainValidation = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeDomainValidation", +}, smithy.ShapeTypeStructure, 9) +var AcmeDomainValidation_AcmeDomainValidationArn *smithy.Schema + +var AcmeDomainValidation_AcmeEndpointArn *smithy.Schema + +var AcmeDomainValidation_DomainName *smithy.Schema + +var AcmeDomainValidation_PrevalidationType *smithy.Schema + +var AcmeDomainValidation_PrevalidationDetails *smithy.Schema + +var AcmeDomainValidation_Status *smithy.Schema + +var AcmeDomainValidation_FailureDetails *smithy.Schema + +var AcmeDomainValidation_CreatedAt *smithy.Schema + +var AcmeDomainValidation_UpdatedAt *smithy.Schema + +var _AcmeDomainValidationArn = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeDomainValidationArn", +}, smithy.ShapeTypeString, 0) + +var AcmeDomainValidationFailureReason = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeDomainValidationFailureReason", +}, smithy.ShapeTypeEnum, 9) +var AcmeDomainValidationFailureReason_ACCESS_DENIED *smithy.Schema + +var AcmeDomainValidationFailureReason_DOMAIN_MISMATCH *smithy.Schema + +var AcmeDomainValidationFailureReason_DOMAIN_NOT_ALLOWED *smithy.Schema + +var AcmeDomainValidationFailureReason_ENDPOINT_NOT_ACTIVE *smithy.Schema + +var AcmeDomainValidationFailureReason_HOSTED_ZONE_NOT_FOUND *smithy.Schema + +var AcmeDomainValidationFailureReason_INTERNAL_FAILURE *smithy.Schema + +var AcmeDomainValidationFailureReason_INVALID_CHANGE_BATCH *smithy.Schema + +var AcmeDomainValidationFailureReason_INVALID_PUBLIC_DOMAIN *smithy.Schema + +var AcmeDomainValidationFailureReason_TIMED_OUT *smithy.Schema + +var _AcmeDomainValidationList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeDomainValidationList", +}, smithy.ShapeTypeList, 1) +var _AcmeDomainValidationList_member *smithy.Schema + +var AcmeDomainValidationStatus = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeDomainValidationStatus", +}, smithy.ShapeTypeEnum, 4) +var AcmeDomainValidationStatus_VALIDATING *smithy.Schema + +var AcmeDomainValidationStatus_VALID *smithy.Schema + +var AcmeDomainValidationStatus_INVALID *smithy.Schema + +var AcmeDomainValidationStatus_DELETING *smithy.Schema + +var AcmeDomainValidationSummary = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeDomainValidationSummary", +}, smithy.ShapeTypeStructure, 9) +var AcmeDomainValidationSummary_AcmeDomainValidationArn *smithy.Schema + +var AcmeDomainValidationSummary_AcmeEndpointArn *smithy.Schema + +var AcmeDomainValidationSummary_DomainName *smithy.Schema + +var AcmeDomainValidationSummary_PrevalidationType *smithy.Schema + +var AcmeDomainValidationSummary_PrevalidationDetails *smithy.Schema + +var AcmeDomainValidationSummary_Status *smithy.Schema + +var AcmeDomainValidationSummary_FailureDetails *smithy.Schema + +var AcmeDomainValidationSummary_CreatedAt *smithy.Schema + +var AcmeDomainValidationSummary_UpdatedAt *smithy.Schema + +var AcmeEndpoint = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeEndpoint", +}, smithy.ShapeTypeStructure, 10) +var AcmeEndpoint_AcmeEndpointArn *smithy.Schema + +var AcmeEndpoint_EndpointUrl *smithy.Schema + +var AcmeEndpoint_Status *smithy.Schema + +var AcmeEndpoint_FailureReason *smithy.Schema + +var AcmeEndpoint_AuthorizationBehavior *smithy.Schema + +var AcmeEndpoint_Contact *smithy.Schema + +var AcmeEndpoint_CertificateAuthority *smithy.Schema + +var AcmeEndpoint_CertificateTags *smithy.Schema + +var AcmeEndpoint_CreatedAt *smithy.Schema + +var AcmeEndpoint_UpdatedAt *smithy.Schema + +var _AcmeEndpointArn = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeEndpointArn", +}, smithy.ShapeTypeString, 0) + +var _AcmeEndpointList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeEndpointList", +}, smithy.ShapeTypeList, 1) +var _AcmeEndpointList_member *smithy.Schema + +var AcmeEndpointStatus = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeEndpointStatus", +}, smithy.ShapeTypeEnum, 4) +var AcmeEndpointStatus_CREATING *smithy.Schema + +var AcmeEndpointStatus_ACTIVE *smithy.Schema + +var AcmeEndpointStatus_DELETING *smithy.Schema + +var AcmeEndpointStatus_FAILED *smithy.Schema + +var AcmeEndpointSummary = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeEndpointSummary", +}, smithy.ShapeTypeStructure, 10) +var AcmeEndpointSummary_AcmeEndpointArn *smithy.Schema + +var AcmeEndpointSummary_EndpointUrl *smithy.Schema + +var AcmeEndpointSummary_Status *smithy.Schema + +var AcmeEndpointSummary_FailureReason *smithy.Schema + +var AcmeEndpointSummary_AuthorizationBehavior *smithy.Schema + +var AcmeEndpointSummary_Contact *smithy.Schema + +var AcmeEndpointSummary_CertificateAuthority *smithy.Schema + +var AcmeEndpointSummary_CertificateTags *smithy.Schema + +var AcmeEndpointSummary_CreatedAt *smithy.Schema + +var AcmeEndpointSummary_UpdatedAt *smithy.Schema + +var AcmeExternalAccountBinding = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeExternalAccountBinding", +}, smithy.ShapeTypeStructure, 8) +var AcmeExternalAccountBinding_AcmeExternalAccountBindingArn *smithy.Schema + +var AcmeExternalAccountBinding_AcmeEndpointArn *smithy.Schema + +var AcmeExternalAccountBinding_RoleArn *smithy.Schema + +var AcmeExternalAccountBinding_ExpiresAt *smithy.Schema + +var AcmeExternalAccountBinding_RevokedAt *smithy.Schema + +var AcmeExternalAccountBinding_LastUsedAt *smithy.Schema + +var AcmeExternalAccountBinding_CreatedAt *smithy.Schema + +var AcmeExternalAccountBinding_UpdatedAt *smithy.Schema + +var _AcmeExternalAccountBindingArn = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeExternalAccountBindingArn", +}, smithy.ShapeTypeString, 0) + +var _AcmeExternalAccountBindingList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeExternalAccountBindingList", +}, smithy.ShapeTypeList, 1) +var _AcmeExternalAccountBindingList_member *smithy.Schema + +var AcmeExternalAccountBindingSummary = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AcmeExternalAccountBindingSummary", +}, smithy.ShapeTypeStructure, 8) +var AcmeExternalAccountBindingSummary_AcmeExternalAccountBindingArn *smithy.Schema + +var AcmeExternalAccountBindingSummary_AcmeEndpointArn *smithy.Schema + +var AcmeExternalAccountBindingSummary_RoleArn *smithy.Schema + +var AcmeExternalAccountBindingSummary_ExpiresAt *smithy.Schema + +var AcmeExternalAccountBindingSummary_RevokedAt *smithy.Schema + +var AcmeExternalAccountBindingSummary_LastUsedAt *smithy.Schema + +var AcmeExternalAccountBindingSummary_CreatedAt *smithy.Schema + +var AcmeExternalAccountBindingSummary_UpdatedAt *smithy.Schema + +var _Arn = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "Arn", +}, smithy.ShapeTypeString, 0) + +var _AvailabilityErrorMessage = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AvailabilityErrorMessage", +}, smithy.ShapeTypeString, 0) + +var _CertificateArn = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateArn", +}, smithy.ShapeTypeString, 0) + +var CertificateAuthority = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateAuthority", +}, smithy.ShapeTypeUnion, 1) +var CertificateAuthority_PublicCertificateAuthority *smithy.Schema + +var _CertificateBody = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateBody", +}, smithy.ShapeTypeString, 0) + +var _CertificateBodyBlob = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateBodyBlob", +}, smithy.ShapeTypeBlob, 0) + +var _CertificateChain = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateChain", +}, smithy.ShapeTypeString, 0) + +var _CertificateChainBlob = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateChainBlob", +}, smithy.ShapeTypeBlob, 0) + +var CertificateDetail = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateDetail", +}, smithy.ShapeTypeStructure, 31) +var CertificateDetail_CertificateArn *smithy.Schema + +var CertificateDetail_DomainName *smithy.Schema + +var CertificateDetail_SubjectAlternativeNames *smithy.Schema + +var CertificateDetail_ManagedBy *smithy.Schema + +var CertificateDetail_DomainValidationOptions *smithy.Schema + +var CertificateDetail_Serial *smithy.Schema + +var CertificateDetail_Subject *smithy.Schema + +var CertificateDetail_Issuer *smithy.Schema + +var CertificateDetail_CreatedAt *smithy.Schema + +var CertificateDetail_IssuedAt *smithy.Schema + +var CertificateDetail_ImportedAt *smithy.Schema + +var CertificateDetail_Status *smithy.Schema + +var CertificateDetail_RevokedAt *smithy.Schema + +var CertificateDetail_RevocationReason *smithy.Schema + +var CertificateDetail_NotBefore *smithy.Schema + +var CertificateDetail_NotAfter *smithy.Schema + +var CertificateDetail_KeyAlgorithm *smithy.Schema + +var CertificateDetail_SignatureAlgorithm *smithy.Schema + +var CertificateDetail_InUseBy *smithy.Schema + +var CertificateDetail_FailureReason *smithy.Schema + +var CertificateDetail_Type *smithy.Schema + +var CertificateDetail_RenewalSummary *smithy.Schema + +var CertificateDetail_KeyUsages *smithy.Schema + +var CertificateDetail_ExtendedKeyUsages *smithy.Schema + +var CertificateDetail_CertificateAuthorityArn *smithy.Schema + +var CertificateDetail_RenewalEligibility *smithy.Schema + +var CertificateDetail_Options *smithy.Schema + +var CertificateDetail_UpdateSummary *smithy.Schema + +var CertificateDetail_CertificateKeyPairOrigin *smithy.Schema + +var CertificateDetail_AcmeEndpointArn *smithy.Schema + +var CertificateDetail_AcmeAccountId *smithy.Schema + +var CertificateExport = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateExport", +}, smithy.ShapeTypeEnum, 2) +var CertificateExport_ENABLED *smithy.Schema + +var CertificateExport_DISABLED *smithy.Schema + +var CertificateFilter = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateFilter", +}, smithy.ShapeTypeUnion, 3) +var CertificateFilter_CertificateArn *smithy.Schema + +var CertificateFilter_X509AttributeFilter *smithy.Schema + +var CertificateFilter_AcmCertificateMetadataFilter *smithy.Schema + +var CertificateFilterStatement = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateFilterStatement", +}, smithy.ShapeTypeUnion, 4) +var CertificateFilterStatement_And *smithy.Schema + +var CertificateFilterStatement_Or *smithy.Schema + +var CertificateFilterStatement_Not *smithy.Schema + +var CertificateFilterStatement_Filter *smithy.Schema + +var _CertificateFilterStatementList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateFilterStatementList", +}, smithy.ShapeTypeList, 1) +var _CertificateFilterStatementList_member *smithy.Schema + +var CertificateKeyPairOrigin = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateKeyPairOrigin", +}, smithy.ShapeTypeEnum, 3) +var CertificateKeyPairOrigin_AWS_MANAGED *smithy.Schema + +var CertificateKeyPairOrigin_ACME *smithy.Schema + +var CertificateKeyPairOrigin_CUSTOMER_PROVIDED *smithy.Schema + +var _CertificateKeyPairOrigins = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateKeyPairOrigins", +}, smithy.ShapeTypeList, 1) +var _CertificateKeyPairOrigins_member *smithy.Schema + +var CertificateManagedBy = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateManagedBy", +}, smithy.ShapeTypeEnum, 1) +var CertificateManagedBy_CLOUDFRONT *smithy.Schema + +var CertificateMetadata = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateMetadata", +}, smithy.ShapeTypeUnion, 1) +var CertificateMetadata_AcmCertificateMetadata *smithy.Schema + +var CertificateOptions = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateOptions", +}, smithy.ShapeTypeStructure, 3) +var CertificateOptions_CertificateTransparencyLoggingPreference *smithy.Schema + +var CertificateOptions_Export *smithy.Schema + +var CertificateOptions_ValidationMethod *smithy.Schema + +var CertificateSearchResult = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateSearchResult", +}, smithy.ShapeTypeStructure, 3) +var CertificateSearchResult_CertificateArn *smithy.Schema + +var CertificateSearchResult_X509Attributes *smithy.Schema + +var CertificateSearchResult_CertificateMetadata *smithy.Schema + +var _CertificateSearchResultList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateSearchResultList", +}, smithy.ShapeTypeList, 1) +var _CertificateSearchResultList_member *smithy.Schema + +var CertificateStatus = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateStatus", +}, smithy.ShapeTypeEnum, 7) +var CertificateStatus_PENDING_VALIDATION *smithy.Schema + +var CertificateStatus_ISSUED *smithy.Schema + +var CertificateStatus_INACTIVE *smithy.Schema + +var CertificateStatus_EXPIRED *smithy.Schema + +var CertificateStatus_VALIDATION_TIMED_OUT *smithy.Schema + +var CertificateStatus_REVOKED *smithy.Schema + +var CertificateStatus_FAILED *smithy.Schema + +var _CertificateStatuses = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateStatuses", +}, smithy.ShapeTypeList, 1) +var _CertificateStatuses_member *smithy.Schema + +var CertificateSummary = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateSummary", +}, smithy.ShapeTypeStructure, 21) +var CertificateSummary_CertificateArn *smithy.Schema + +var CertificateSummary_DomainName *smithy.Schema + +var CertificateSummary_SubjectAlternativeNameSummaries *smithy.Schema + +var CertificateSummary_HasAdditionalSubjectAlternativeNames *smithy.Schema + +var CertificateSummary_Status *smithy.Schema + +var CertificateSummary_Type *smithy.Schema + +var CertificateSummary_KeyAlgorithm *smithy.Schema + +var CertificateSummary_KeyUsages *smithy.Schema + +var CertificateSummary_ExtendedKeyUsages *smithy.Schema + +var CertificateSummary_ExportOption *smithy.Schema + +var CertificateSummary_InUse *smithy.Schema + +var CertificateSummary_Exported *smithy.Schema + +var CertificateSummary_RenewalEligibility *smithy.Schema + +var CertificateSummary_NotBefore *smithy.Schema + +var CertificateSummary_NotAfter *smithy.Schema + +var CertificateSummary_CreatedAt *smithy.Schema + +var CertificateSummary_IssuedAt *smithy.Schema + +var CertificateSummary_ImportedAt *smithy.Schema + +var CertificateSummary_RevokedAt *smithy.Schema + +var CertificateSummary_ManagedBy *smithy.Schema + +var CertificateSummary_CertificateKeyPairOrigin *smithy.Schema + +var _CertificateSummaryList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateSummaryList", +}, smithy.ShapeTypeList, 1) +var _CertificateSummaryList_member *smithy.Schema + +var CertificateTransparencyLoggingPreference = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateTransparencyLoggingPreference", +}, smithy.ShapeTypeEnum, 2) +var CertificateTransparencyLoggingPreference_ENABLED *smithy.Schema + +var CertificateTransparencyLoggingPreference_DISABLED *smithy.Schema + +var CertificateType = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CertificateType", +}, smithy.ShapeTypeEnum, 3) +var CertificateType_IMPORTED *smithy.Schema + +var CertificateType_AMAZON_ISSUED *smithy.Schema + +var CertificateType_PRIVATE *smithy.Schema + +var CommonNameFilter = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CommonNameFilter", +}, smithy.ShapeTypeStructure, 2) +var CommonNameFilter_Value *smithy.Schema + +var CommonNameFilter_ComparisonOperator *smithy.Schema + +var ComparisonOperator = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ComparisonOperator", +}, smithy.ShapeTypeEnum, 2) +var ComparisonOperator_CONTAINS *smithy.Schema + +var ComparisonOperator_EQUALS *smithy.Schema + +var ConflictException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ConflictException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var ConflictException_message *smithy.Schema + +var _ContactList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ContactList", +}, smithy.ShapeTypeList, 1, &smithytraits.Sensitive{}) +var _ContactList_member *smithy.Schema + +var _CoralAvailabilityThrottledResource = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CoralAvailabilityThrottledResource", +}, smithy.ShapeTypeString, 0) + +var _CoralAvailabilityThrottlingReason = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CoralAvailabilityThrottlingReason", +}, smithy.ShapeTypeString, 0) + +var CustomAttribute = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CustomAttribute", +}, smithy.ShapeTypeStructure, 2) +var CustomAttribute_ObjectIdentifier *smithy.Schema + +var CustomAttribute_Value *smithy.Schema + +var _CustomAttributeList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CustomAttributeList", +}, smithy.ShapeTypeList, 1) +var _CustomAttributeList_member *smithy.Schema + +var DistinguishedName = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DistinguishedName", +}, smithy.ShapeTypeStructure, 16) +var DistinguishedName_CommonName *smithy.Schema + +var DistinguishedName_DomainComponents *smithy.Schema + +var DistinguishedName_Country *smithy.Schema + +var DistinguishedName_CustomAttributes *smithy.Schema + +var DistinguishedName_DistinguishedNameQualifier *smithy.Schema + +var DistinguishedName_GenerationQualifier *smithy.Schema + +var DistinguishedName_GivenName *smithy.Schema + +var DistinguishedName_Initials *smithy.Schema + +var DistinguishedName_Locality *smithy.Schema + +var DistinguishedName_Organization *smithy.Schema + +var DistinguishedName_OrganizationalUnit *smithy.Schema + +var DistinguishedName_Pseudonym *smithy.Schema + +var DistinguishedName_SerialNumber *smithy.Schema + +var DistinguishedName_State *smithy.Schema + +var DistinguishedName_Surname *smithy.Schema + +var DistinguishedName_Title *smithy.Schema + +var DnsNameFilter = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DnsNameFilter", +}, smithy.ShapeTypeStructure, 2) +var DnsNameFilter_Value *smithy.Schema + +var DnsNameFilter_ComparisonOperator *smithy.Schema + +var DnsPrevalidationDetails = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DnsPrevalidationDetails", +}, smithy.ShapeTypeStructure, 3) +var DnsPrevalidationDetails_DomainScope *smithy.Schema + +var DnsPrevalidationDetails_HostedZoneId *smithy.Schema + +var DnsPrevalidationDetails_ResourceRecord *smithy.Schema + +var DnsPrevalidationOptions = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DnsPrevalidationOptions", +}, smithy.ShapeTypeStructure, 2) +var DnsPrevalidationOptions_DomainScope *smithy.Schema + +var DnsPrevalidationOptions_HostedZoneId *smithy.Schema + +var DnsValidationChallenge = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DnsValidationChallenge", +}, smithy.ShapeTypeStructure, 1) +var DnsValidationChallenge_ResourceRecord *smithy.Schema + +var _DomainComponentList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainComponentList", +}, smithy.ShapeTypeList, 1) +var _DomainComponentList_member *smithy.Schema + +var _DomainList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainList", +}, smithy.ShapeTypeList, 1) +var _DomainList_member *smithy.Schema + +var _DomainName = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainName", +}, smithy.ShapeTypeString, 0) + +var _DomainNameString = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainNameString", +}, smithy.ShapeTypeString, 0) + +var DomainScope = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainScope", +}, smithy.ShapeTypeStructure, 3) +var DomainScope_ExactDomain *smithy.Schema + +var DomainScope_Subdomains *smithy.Schema + +var DomainScope_Wildcards *smithy.Schema + +var DomainScopeOption = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainScopeOption", +}, smithy.ShapeTypeEnum, 2) +var DomainScopeOption_ENABLED *smithy.Schema + +var DomainScopeOption_DISABLED *smithy.Schema + +var DomainStatus = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainStatus", +}, smithy.ShapeTypeEnum, 3) +var DomainStatus_PENDING_VALIDATION *smithy.Schema + +var DomainStatus_SUCCESS *smithy.Schema + +var DomainStatus_FAILED *smithy.Schema + +var DomainValidation = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainValidation", +}, smithy.ShapeTypeStructure, 7) +var DomainValidation_DomainName *smithy.Schema + +var DomainValidation_ValidationEmails *smithy.Schema + +var DomainValidation_ValidationDomain *smithy.Schema + +var DomainValidation_ValidationStatus *smithy.Schema + +var DomainValidation_ResourceRecord *smithy.Schema + +var DomainValidation_HttpRedirect *smithy.Schema + +var DomainValidation_ValidationMethod *smithy.Schema + +var _DomainValidationList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainValidationList", +}, smithy.ShapeTypeList, 1) +var _DomainValidationList_member *smithy.Schema + +var DomainValidationMethodUpdateSummary = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainValidationMethodUpdateSummary", +}, smithy.ShapeTypeStructure, 2) +var DomainValidationMethodUpdateSummary_From *smithy.Schema + +var DomainValidationMethodUpdateSummary_To *smithy.Schema + +var DomainValidationOption = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainValidationOption", +}, smithy.ShapeTypeStructure, 2) +var DomainValidationOption_DomainName *smithy.Schema + +var DomainValidationOption_ValidationDomain *smithy.Schema + +var _DomainValidationOptionList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainValidationOptionList", +}, smithy.ShapeTypeList, 1) +var _DomainValidationOptionList_member *smithy.Schema + +var DomainValidationSummary = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainValidationSummary", +}, smithy.ShapeTypeStructure, 3) +var DomainValidationSummary_DomainName *smithy.Schema + +var DomainValidationSummary_ActiveValidationConfiguration *smithy.Schema + +var DomainValidationSummary_RequestedValidationConfiguration *smithy.Schema + +var _DomainValidationSummaryList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DomainValidationSummaryList", +}, smithy.ShapeTypeList, 1) +var _DomainValidationSummaryList_member *smithy.Schema + +var EmailValidationChallenge = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "EmailValidationChallenge", +}, smithy.ShapeTypeStructure, 2) +var EmailValidationChallenge_ValidationEmails *smithy.Schema + +var EmailValidationChallenge_ValidationDomain *smithy.Schema + +var Expiration = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "Expiration", +}, smithy.ShapeTypeStructure, 2) +var Expiration_Value *smithy.Schema + +var Expiration_Type *smithy.Schema + +var ExpiryEventsConfiguration = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ExpiryEventsConfiguration", +}, smithy.ShapeTypeStructure, 1) +var ExpiryEventsConfiguration_DaysBeforeExpiry *smithy.Schema + +var ExtendedKeyUsage = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ExtendedKeyUsage", +}, smithy.ShapeTypeStructure, 2) +var ExtendedKeyUsage_Name *smithy.Schema + +var ExtendedKeyUsage_OID *smithy.Schema + +var _ExtendedKeyUsageFilterList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ExtendedKeyUsageFilterList", +}, smithy.ShapeTypeList, 1) +var _ExtendedKeyUsageFilterList_member *smithy.Schema + +var _ExtendedKeyUsageList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ExtendedKeyUsageList", +}, smithy.ShapeTypeList, 1) +var _ExtendedKeyUsageList_member *smithy.Schema + +var ExtendedKeyUsageName = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ExtendedKeyUsageName", +}, smithy.ShapeTypeEnum, 12) +var ExtendedKeyUsageName_TLS_WEB_SERVER_AUTHENTICATION *smithy.Schema + +var ExtendedKeyUsageName_TLS_WEB_CLIENT_AUTHENTICATION *smithy.Schema + +var ExtendedKeyUsageName_CODE_SIGNING *smithy.Schema + +var ExtendedKeyUsageName_EMAIL_PROTECTION *smithy.Schema + +var ExtendedKeyUsageName_TIME_STAMPING *smithy.Schema + +var ExtendedKeyUsageName_OCSP_SIGNING *smithy.Schema + +var ExtendedKeyUsageName_IPSEC_END_SYSTEM *smithy.Schema + +var ExtendedKeyUsageName_IPSEC_TUNNEL *smithy.Schema + +var ExtendedKeyUsageName_IPSEC_USER *smithy.Schema + +var ExtendedKeyUsageName_ANY *smithy.Schema + +var ExtendedKeyUsageName_NONE *smithy.Schema + +var ExtendedKeyUsageName_CUSTOM *smithy.Schema + +var _ExtendedKeyUsageNames = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ExtendedKeyUsageNames", +}, smithy.ShapeTypeList, 1) +var _ExtendedKeyUsageNames_member *smithy.Schema + +var FailureDetails = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "FailureDetails", +}, smithy.ShapeTypeStructure, 2) +var FailureDetails_Reason *smithy.Schema + +var FailureDetails_Message *smithy.Schema + +var FailureReason = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "FailureReason", +}, smithy.ShapeTypeEnum, 17) +var FailureReason_NO_AVAILABLE_CONTACTS *smithy.Schema + +var FailureReason_ADDITIONAL_VERIFICATION_REQUIRED *smithy.Schema + +var FailureReason_DOMAIN_NOT_ALLOWED *smithy.Schema + +var FailureReason_INVALID_PUBLIC_DOMAIN *smithy.Schema + +var FailureReason_DOMAIN_VALIDATION_DENIED *smithy.Schema + +var FailureReason_CAA_ERROR *smithy.Schema + +var FailureReason_PCA_LIMIT_EXCEEDED *smithy.Schema + +var FailureReason_PCA_INVALID_ARN *smithy.Schema + +var FailureReason_PCA_INVALID_STATE *smithy.Schema + +var FailureReason_PCA_REQUEST_FAILED *smithy.Schema + +var FailureReason_PCA_NAME_CONSTRAINTS_VALIDATION *smithy.Schema + +var FailureReason_PCA_RESOURCE_NOT_FOUND *smithy.Schema + +var FailureReason_PCA_INVALID_ARGS *smithy.Schema + +var FailureReason_PCA_INVALID_DURATION *smithy.Schema + +var FailureReason_PCA_ACCESS_DENIED *smithy.Schema + +var FailureReason_SLR_NOT_FOUND *smithy.Schema + +var FailureReason_OTHER *smithy.Schema + +var Filters = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "Filters", +}, smithy.ShapeTypeStructure, 5) +var Filters_extendedKeyUsage *smithy.Schema + +var Filters_keyUsage *smithy.Schema + +var Filters_keyTypes *smithy.Schema + +var Filters_exportOption *smithy.Schema + +var Filters_managedBy *smithy.Schema + +var _FilterString = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "FilterString", +}, smithy.ShapeTypeString, 0) + +var GeneralName = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "GeneralName", +}, smithy.ShapeTypeUnion, 7) +var GeneralName_DirectoryName *smithy.Schema + +var GeneralName_DnsName *smithy.Schema + +var GeneralName_IpAddress *smithy.Schema + +var GeneralName_OtherName *smithy.Schema + +var GeneralName_RegisteredId *smithy.Schema + +var GeneralName_Rfc822Name *smithy.Schema + +var GeneralName_UniformResourceIdentifier *smithy.Schema + +var _GeneralNameList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "GeneralNameList", +}, smithy.ShapeTypeList, 1) +var _GeneralNameList_member *smithy.Schema + +var _HostedZoneId = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "HostedZoneId", +}, smithy.ShapeTypeString, 0) + +var HttpRedirect = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "HttpRedirect", +}, smithy.ShapeTypeStructure, 2) +var HttpRedirect_RedirectFrom *smithy.Schema + +var HttpRedirect_RedirectTo *smithy.Schema + +var _IdempotencyToken = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "IdempotencyToken", +}, smithy.ShapeTypeString, 0) + +var InternalServerException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "InternalServerException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "server"}) +var InternalServerException_message *smithy.Schema + +var _InUseList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "InUseList", +}, smithy.ShapeTypeList, 1) +var _InUseList_member *smithy.Schema + +var InvalidArgsException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "InvalidArgsException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var InvalidArgsException_message *smithy.Schema + +var InvalidArnException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "InvalidArnException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var InvalidArnException_message *smithy.Schema + +var InvalidDomainValidationOptionsException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "InvalidDomainValidationOptionsException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var InvalidDomainValidationOptionsException_message *smithy.Schema + +var InvalidParameterException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "InvalidParameterException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var InvalidParameterException_message *smithy.Schema + +var InvalidStateException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "InvalidStateException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var InvalidStateException_message *smithy.Schema + +var InvalidTagException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "InvalidTagException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var InvalidTagException_message *smithy.Schema + +var KeyAlgorithm = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "KeyAlgorithm", +}, smithy.ShapeTypeEnum, 7) +var KeyAlgorithm_RSA_1024 *smithy.Schema + +var KeyAlgorithm_RSA_2048 *smithy.Schema + +var KeyAlgorithm_RSA_3072 *smithy.Schema + +var KeyAlgorithm_RSA_4096 *smithy.Schema + +var KeyAlgorithm_EC_prime256v1 *smithy.Schema + +var KeyAlgorithm_EC_secp384r1 *smithy.Schema + +var KeyAlgorithm_EC_secp521r1 *smithy.Schema + +var _KeyAlgorithmList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "KeyAlgorithmList", +}, smithy.ShapeTypeList, 1) +var _KeyAlgorithmList_member *smithy.Schema + +var KeyUsage = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "KeyUsage", +}, smithy.ShapeTypeStructure, 1) +var KeyUsage_Name *smithy.Schema + +var _KeyUsageFilterList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "KeyUsageFilterList", +}, smithy.ShapeTypeList, 1) +var _KeyUsageFilterList_member *smithy.Schema + +var _KeyUsageList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "KeyUsageList", +}, smithy.ShapeTypeList, 1) +var _KeyUsageList_member *smithy.Schema + +var KeyUsageName = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "KeyUsageName", +}, smithy.ShapeTypeEnum, 11) +var KeyUsageName_DIGITAL_SIGNATURE *smithy.Schema + +var KeyUsageName_NON_REPUDATION *smithy.Schema + +var KeyUsageName_KEY_ENCIPHERMENT *smithy.Schema + +var KeyUsageName_DATA_ENCIPHERMENT *smithy.Schema + +var KeyUsageName_KEY_AGREEMENT *smithy.Schema + +var KeyUsageName_CERTIFICATE_SIGNING *smithy.Schema + +var KeyUsageName_CRL_SIGNING *smithy.Schema + +var KeyUsageName_ENCHIPER_ONLY *smithy.Schema + +var KeyUsageName_DECIPHER_ONLY *smithy.Schema + +var KeyUsageName_ANY *smithy.Schema + +var KeyUsageName_CUSTOM *smithy.Schema + +var _KeyUsageNames = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "KeyUsageNames", +}, smithy.ShapeTypeList, 1) +var _KeyUsageNames_member *smithy.Schema + +var LimitExceededException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "LimitExceededException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var LimitExceededException_message *smithy.Schema + +var _MacKey = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "MacKey", +}, smithy.ShapeTypeString, 0, &smithytraits.Sensitive{}) + +var _MaxItems = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "MaxItems", +}, smithy.ShapeTypeInteger, 0) + +var _NextToken = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "NextToken", +}, smithy.ShapeTypeString, 0) + +var _NullableBoolean = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "NullableBoolean", +}, smithy.ShapeTypeBoolean, 0) + +var OtherName = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "OtherName", +}, smithy.ShapeTypeStructure, 2) +var OtherName_ObjectIdentifier *smithy.Schema + +var OtherName_Value *smithy.Schema + +var _PassphraseBlob = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "PassphraseBlob", +}, smithy.ShapeTypeBlob, 0, &smithytraits.Sensitive{}) + +var _PcaArn = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "PcaArn", +}, smithy.ShapeTypeString, 0) + +var _PositiveInteger = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "PositiveInteger", +}, smithy.ShapeTypeInteger, 0) + +var PrevalidationDetails = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "PrevalidationDetails", +}, smithy.ShapeTypeUnion, 1) +var PrevalidationDetails_DnsPrevalidation *smithy.Schema + +var PrevalidationOptions = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "PrevalidationOptions", +}, smithy.ShapeTypeUnion, 1) +var PrevalidationOptions_DnsPrevalidation *smithy.Schema + +var PrevalidationType = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "PrevalidationType", +}, smithy.ShapeTypeEnum, 1) +var PrevalidationType_DNS_PREVALIDATION *smithy.Schema + +var _PrivateKey = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "PrivateKey", +}, smithy.ShapeTypeString, 0, &smithytraits.Sensitive{}) + +var _PrivateKeyBlob = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "PrivateKeyBlob", +}, smithy.ShapeTypeBlob, 0, &smithytraits.Sensitive{}) + +var PublicCertificateAuthority = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "PublicCertificateAuthority", +}, smithy.ShapeTypeStructure, 1) +var PublicCertificateAuthority_AllowedKeyAlgorithms *smithy.Schema + +var PublicKeyAlgorithm = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "PublicKeyAlgorithm", +}, smithy.ShapeTypeEnum, 3) +var PublicKeyAlgorithm_RSA_2048 *smithy.Schema + +var PublicKeyAlgorithm_EC_PRIME256_V1 *smithy.Schema + +var PublicKeyAlgorithm_EC_SECP384_R1 *smithy.Schema + +var _PublicKeyAlgorithmList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "PublicKeyAlgorithmList", +}, smithy.ShapeTypeList, 1) +var _PublicKeyAlgorithmList_member *smithy.Schema + +var RecordType = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RecordType", +}, smithy.ShapeTypeEnum, 1) +var RecordType_CNAME *smithy.Schema + +var RenewalEligibility = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RenewalEligibility", +}, smithy.ShapeTypeEnum, 2) +var RenewalEligibility_ELIGIBLE *smithy.Schema + +var RenewalEligibility_INELIGIBLE *smithy.Schema + +var RenewalStatus = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RenewalStatus", +}, smithy.ShapeTypeEnum, 4) +var RenewalStatus_PENDING_AUTO_RENEWAL *smithy.Schema + +var RenewalStatus_PENDING_VALIDATION *smithy.Schema + +var RenewalStatus_SUCCESS *smithy.Schema + +var RenewalStatus_FAILED *smithy.Schema + +var RenewalSummary = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RenewalSummary", +}, smithy.ShapeTypeStructure, 4) +var RenewalSummary_RenewalStatus *smithy.Schema + +var RenewalSummary_DomainValidationOptions *smithy.Schema + +var RenewalSummary_RenewalStatusReason *smithy.Schema + +var RenewalSummary_UpdatedAt *smithy.Schema + +var RequestInProgressException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RequestInProgressException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var RequestInProgressException_message *smithy.Schema + +var ResourceInUseException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ResourceInUseException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var ResourceInUseException_message *smithy.Schema + +var ResourceNotFoundException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ResourceNotFoundException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var ResourceNotFoundException_message *smithy.Schema + +var ResourceRecord = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ResourceRecord", +}, smithy.ShapeTypeStructure, 3) +var ResourceRecord_Name *smithy.Schema + +var ResourceRecord_Type *smithy.Schema + +var ResourceRecord_Value *smithy.Schema + +var RevocationReason = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RevocationReason", +}, smithy.ShapeTypeEnum, 11) +var RevocationReason_UNSPECIFIED *smithy.Schema + +var RevocationReason_KEY_COMPROMISE *smithy.Schema + +var RevocationReason_CA_COMPROMISE *smithy.Schema + +var RevocationReason_AFFILIATION_CHANGED *smithy.Schema + +var RevocationReason_SUPERCEDED *smithy.Schema + +var RevocationReason_SUPERSEDED *smithy.Schema + +var RevocationReason_CESSATION_OF_OPERATION *smithy.Schema + +var RevocationReason_CERTIFICATE_HOLD *smithy.Schema + +var RevocationReason_REMOVE_FROM_CRL *smithy.Schema + +var RevocationReason_PRIVILEGE_WITHDRAWN *smithy.Schema + +var RevocationReason_A_A_COMPROMISE *smithy.Schema + +var _RoleArn = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RoleArn", +}, smithy.ShapeTypeString, 0) + +var SearchCertificatesSortBy = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "SearchCertificatesSortBy", +}, smithy.ShapeTypeEnum, 21) +var SearchCertificatesSortBy_CREATED_AT *smithy.Schema + +var SearchCertificatesSortBy_NOT_AFTER *smithy.Schema + +var SearchCertificatesSortBy_STATUS *smithy.Schema + +var SearchCertificatesSortBy_RENEWAL_STATUS *smithy.Schema + +var SearchCertificatesSortBy_EXPORTED *smithy.Schema + +var SearchCertificatesSortBy_IN_USE *smithy.Schema + +var SearchCertificatesSortBy_NOT_BEFORE *smithy.Schema + +var SearchCertificatesSortBy_KEY_ALGORITHM *smithy.Schema + +var SearchCertificatesSortBy_TYPE *smithy.Schema + +var SearchCertificatesSortBy_CERTIFICATE_ARN *smithy.Schema + +var SearchCertificatesSortBy_COMMON_NAME *smithy.Schema + +var SearchCertificatesSortBy_REVOKED_AT *smithy.Schema + +var SearchCertificatesSortBy_RENEWAL_ELIGIBILITY *smithy.Schema + +var SearchCertificatesSortBy_ISSUED_AT *smithy.Schema + +var SearchCertificatesSortBy_MANAGED_BY *smithy.Schema + +var SearchCertificatesSortBy_EXPORT_OPTION *smithy.Schema + +var SearchCertificatesSortBy_VALIDATION_METHOD *smithy.Schema + +var SearchCertificatesSortBy_IMPORTED_AT *smithy.Schema + +var SearchCertificatesSortBy_ACME_ENDPOINT_ARN *smithy.Schema + +var SearchCertificatesSortBy_ACME_ACCOUNT_ID *smithy.Schema + +var SearchCertificatesSortBy_CERTIFICATE_KEY_PAIR_ORIGIN *smithy.Schema + +var SearchCertificatesSortOrder = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "SearchCertificatesSortOrder", +}, smithy.ShapeTypeEnum, 2) +var SearchCertificatesSortOrder_ASCENDING *smithy.Schema + +var SearchCertificatesSortOrder_DESCENDING *smithy.Schema + +var _SearchMaxResults = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "SearchMaxResults", +}, smithy.ShapeTypeInteger, 0) + +var _SerialNumber = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "SerialNumber", +}, smithy.ShapeTypeString, 0) + +var _ServiceErrorMessage = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ServiceErrorMessage", +}, smithy.ShapeTypeString, 0) + +var ServiceQuotaExceededException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ServiceQuotaExceededException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var ServiceQuotaExceededException_message *smithy.Schema + +var SortBy = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "SortBy", +}, smithy.ShapeTypeEnum, 1) +var SortBy_CREATED_AT *smithy.Schema + +var SortOrder = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "SortOrder", +}, smithy.ShapeTypeEnum, 2) +var SortOrder_ASCENDING *smithy.Schema + +var SortOrder_DESCENDING *smithy.Schema + +var _String = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "String", +}, smithy.ShapeTypeString, 0) + +var SubjectAlternativeNameFilter = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "SubjectAlternativeNameFilter", +}, smithy.ShapeTypeUnion, 1) +var SubjectAlternativeNameFilter_DnsName *smithy.Schema + +var SubjectFilter = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "SubjectFilter", +}, smithy.ShapeTypeUnion, 1) +var SubjectFilter_CommonName *smithy.Schema + +var Tag = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "Tag", +}, smithy.ShapeTypeStructure, 2) +var Tag_Key *smithy.Schema + +var Tag_Value *smithy.Schema + +var _TagKey = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "TagKey", +}, smithy.ShapeTypeString, 0) + +var _TagKeyList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "TagKeyList", +}, smithy.ShapeTypeList, 1) +var _TagKeyList_member *smithy.Schema + +var _TagList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "TagList", +}, smithy.ShapeTypeList, 1) +var _TagList_member *smithy.Schema + +var TagPolicyException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "TagPolicyException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var TagPolicyException_message *smithy.Schema + +var _TagValue = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "TagValue", +}, smithy.ShapeTypeString, 0) + +var ThrottlingException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ThrottlingException", +}, smithy.ShapeTypeStructure, 2, &smithytraits.Error{Type: "client"}, + &smithytraits.HTTPError{Code: 400}, + &smithytraits.AWSQueryError{ErrorCode: "Throttling", + StatusCode: 400}) +var ThrottlingException_message *smithy.Schema + +var ThrottlingException_throttlingReasons *smithy.Schema + +var ThrottlingReason = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ThrottlingReason", +}, smithy.ShapeTypeStructure, 2) +var ThrottlingReason_reason *smithy.Schema + +var ThrottlingReason_resource *smithy.Schema + +var _ThrottlingReasonList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ThrottlingReasonList", +}, smithy.ShapeTypeList, 1) +var _ThrottlingReasonList_member *smithy.Schema + +var TimestampRange = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "TimestampRange", +}, smithy.ShapeTypeStructure, 2) +var TimestampRange_Start *smithy.Schema + +var TimestampRange_End *smithy.Schema + +var TimeType = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "TimeType", +}, smithy.ShapeTypeEnum, 3) +var TimeType_MINUTES *smithy.Schema + +var TimeType_HOURS *smithy.Schema + +var TimeType_DAYS *smithy.Schema + +var TooManyTagsException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "TooManyTagsException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}) +var TooManyTagsException_message *smithy.Schema + +var _TStamp = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "TStamp", +}, smithy.ShapeTypeTimestamp, 0) + +var UpdateStatus = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "UpdateStatus", +}, smithy.ShapeTypeEnum, 3) +var UpdateStatus_PENDING_DOMAIN_VALIDATION *smithy.Schema + +var UpdateStatus_SUCCESS *smithy.Schema + +var UpdateStatus_FAILED *smithy.Schema + +var UpdateSummary = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "UpdateSummary", +}, smithy.ShapeTypeStructure, 5) +var UpdateSummary_Status *smithy.Schema + +var UpdateSummary_Type *smithy.Schema + +var UpdateSummary_DomainValidationMethodUpdateSummary *smithy.Schema + +var UpdateSummary_RequestedAt *smithy.Schema + +var UpdateSummary_UpdatedAt *smithy.Schema + +var UpdateType = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "UpdateType", +}, smithy.ShapeTypeEnum, 1) +var UpdateType_DOMAIN_VALIDATION_METHOD *smithy.Schema + +var ValidationChallenge = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ValidationChallenge", +}, smithy.ShapeTypeUnion, 2) +var ValidationChallenge_EmailValidationChallenge *smithy.Schema + +var ValidationChallenge_DnsValidationChallenge *smithy.Schema + +var ValidationConfiguration = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ValidationConfiguration", +}, smithy.ShapeTypeStructure, 3) +var ValidationConfiguration_ValidationMethod *smithy.Schema + +var ValidationConfiguration_ValidationChallenge *smithy.Schema + +var ValidationConfiguration_ValidationStatus *smithy.Schema + +var _ValidationEmailList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ValidationEmailList", +}, smithy.ShapeTypeList, 1) +var _ValidationEmailList_member *smithy.Schema + +var ValidationException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ValidationException", +}, smithy.ShapeTypeStructure, 1, &smithytraits.Error{Type: "client"}, + &smithytraits.HTTPError{Code: 400}, + &smithytraits.AWSQueryError{ErrorCode: "ValidationError", + StatusCode: 400}) +var ValidationException_message *smithy.Schema + +var _ValidationExceptionMessage = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ValidationExceptionMessage", +}, smithy.ShapeTypeString, 0) + +var ValidationMethod = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ValidationMethod", +}, smithy.ShapeTypeEnum, 3) +var ValidationMethod_EMAIL *smithy.Schema + +var ValidationMethod_DNS *smithy.Schema + +var ValidationMethod_HTTP *smithy.Schema + +var X509AttributeFilter = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "X509AttributeFilter", +}, smithy.ShapeTypeUnion, 8) +var X509AttributeFilter_Subject *smithy.Schema + +var X509AttributeFilter_SubjectAlternativeName *smithy.Schema + +var X509AttributeFilter_ExtendedKeyUsage *smithy.Schema + +var X509AttributeFilter_KeyUsage *smithy.Schema + +var X509AttributeFilter_KeyAlgorithm *smithy.Schema + +var X509AttributeFilter_SerialNumber *smithy.Schema + +var X509AttributeFilter_NotAfter *smithy.Schema + +var X509AttributeFilter_NotBefore *smithy.Schema + +var X509Attributes = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "X509Attributes", +}, smithy.ShapeTypeStructure, 9) +var X509Attributes_Issuer *smithy.Schema + +var X509Attributes_Subject *smithy.Schema + +var X509Attributes_SubjectAlternativeNames *smithy.Schema + +var X509Attributes_ExtendedKeyUsages *smithy.Schema + +var X509Attributes_KeyAlgorithm *smithy.Schema + +var X509Attributes_KeyUsages *smithy.Schema + +var X509Attributes_SerialNumber *smithy.Schema + +var X509Attributes_NotAfter *smithy.Schema + +var X509Attributes_NotBefore *smithy.Schema + +var AddTagsToCertificateRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "AddTagsToCertificateRequest", +}, smithy.ShapeTypeStructure, 2) +var AddTagsToCertificateRequest_CertificateArn *smithy.Schema + +var AddTagsToCertificateRequest_Tags *smithy.Schema + +var CreateAcmeDomainValidationRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CreateAcmeDomainValidationRequest", +}, smithy.ShapeTypeStructure, 5) +var CreateAcmeDomainValidationRequest_IdempotencyToken *smithy.Schema + +var CreateAcmeDomainValidationRequest_AcmeEndpointArn *smithy.Schema + +var CreateAcmeDomainValidationRequest_DomainName *smithy.Schema + +var CreateAcmeDomainValidationRequest_PrevalidationOptions *smithy.Schema + +var CreateAcmeDomainValidationRequest_Tags *smithy.Schema + +var CreateAcmeDomainValidationResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CreateAcmeDomainValidationResponse", +}, smithy.ShapeTypeStructure, 1) +var CreateAcmeDomainValidationResponse_AcmeDomainValidationArn *smithy.Schema + +var CreateAcmeEndpointRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CreateAcmeEndpointRequest", +}, smithy.ShapeTypeStructure, 6) +var CreateAcmeEndpointRequest_IdempotencyToken *smithy.Schema + +var CreateAcmeEndpointRequest_AuthorizationBehavior *smithy.Schema + +var CreateAcmeEndpointRequest_Contact *smithy.Schema + +var CreateAcmeEndpointRequest_CertificateAuthority *smithy.Schema + +var CreateAcmeEndpointRequest_Tags *smithy.Schema + +var CreateAcmeEndpointRequest_CertificateTags *smithy.Schema + +var CreateAcmeEndpointResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CreateAcmeEndpointResponse", +}, smithy.ShapeTypeStructure, 1) +var CreateAcmeEndpointResponse_AcmeEndpointArn *smithy.Schema + +var CreateAcmeExternalAccountBindingRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CreateAcmeExternalAccountBindingRequest", +}, smithy.ShapeTypeStructure, 5) +var CreateAcmeExternalAccountBindingRequest_IdempotencyToken *smithy.Schema + +var CreateAcmeExternalAccountBindingRequest_AcmeEndpointArn *smithy.Schema + +var CreateAcmeExternalAccountBindingRequest_RoleArn *smithy.Schema + +var CreateAcmeExternalAccountBindingRequest_Expiration *smithy.Schema + +var CreateAcmeExternalAccountBindingRequest_Tags *smithy.Schema + +var CreateAcmeExternalAccountBindingResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "CreateAcmeExternalAccountBindingResponse", +}, smithy.ShapeTypeStructure, 1) +var CreateAcmeExternalAccountBindingResponse_ExternalAccountBinding *smithy.Schema + +var DeleteAcmeDomainValidationRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DeleteAcmeDomainValidationRequest", +}, smithy.ShapeTypeStructure, 1) +var DeleteAcmeDomainValidationRequest_AcmeDomainValidationArn *smithy.Schema + +var DeleteAcmeEndpointRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DeleteAcmeEndpointRequest", +}, smithy.ShapeTypeStructure, 1) +var DeleteAcmeEndpointRequest_AcmeEndpointArn *smithy.Schema + +var DeleteAcmeExternalAccountBindingRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DeleteAcmeExternalAccountBindingRequest", +}, smithy.ShapeTypeStructure, 1) +var DeleteAcmeExternalAccountBindingRequest_AcmeExternalAccountBindingArn *smithy.Schema + +var DeleteCertificateRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DeleteCertificateRequest", +}, smithy.ShapeTypeStructure, 1) +var DeleteCertificateRequest_CertificateArn *smithy.Schema + +var DescribeAcmeAccountRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeAcmeAccountRequest", +}, smithy.ShapeTypeStructure, 2) +var DescribeAcmeAccountRequest_AcmeEndpointArn *smithy.Schema + +var DescribeAcmeAccountRequest_AccountUrl *smithy.Schema + +var DescribeAcmeAccountResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeAcmeAccountResponse", +}, smithy.ShapeTypeStructure, 1) +var DescribeAcmeAccountResponse_AcmeAccount *smithy.Schema + +var DescribeAcmeDomainValidationRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeAcmeDomainValidationRequest", +}, smithy.ShapeTypeStructure, 1) +var DescribeAcmeDomainValidationRequest_AcmeDomainValidationArn *smithy.Schema + +var DescribeAcmeDomainValidationResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeAcmeDomainValidationResponse", +}, smithy.ShapeTypeStructure, 1) +var DescribeAcmeDomainValidationResponse_AcmeDomainValidation *smithy.Schema + +var DescribeAcmeEndpointRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeAcmeEndpointRequest", +}, smithy.ShapeTypeStructure, 1) +var DescribeAcmeEndpointRequest_AcmeEndpointArn *smithy.Schema + +var DescribeAcmeEndpointResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeAcmeEndpointResponse", +}, smithy.ShapeTypeStructure, 1) +var DescribeAcmeEndpointResponse_AcmeEndpoint *smithy.Schema + +var DescribeAcmeExternalAccountBindingRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeAcmeExternalAccountBindingRequest", +}, smithy.ShapeTypeStructure, 1) +var DescribeAcmeExternalAccountBindingRequest_AcmeExternalAccountBindingArn *smithy.Schema + +var DescribeAcmeExternalAccountBindingResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeAcmeExternalAccountBindingResponse", +}, smithy.ShapeTypeStructure, 1) +var DescribeAcmeExternalAccountBindingResponse_ExternalAccountBinding *smithy.Schema + +var DescribeCertificateRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeCertificateRequest", +}, smithy.ShapeTypeStructure, 1) +var DescribeCertificateRequest_CertificateArn *smithy.Schema + +var DescribeCertificateResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "DescribeCertificateResponse", +}, smithy.ShapeTypeStructure, 1) +var DescribeCertificateResponse_Certificate *smithy.Schema + +var ExportCertificateRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ExportCertificateRequest", +}, smithy.ShapeTypeStructure, 2) +var ExportCertificateRequest_CertificateArn *smithy.Schema + +var ExportCertificateRequest_Passphrase *smithy.Schema + +var ExportCertificateResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ExportCertificateResponse", +}, smithy.ShapeTypeStructure, 3) +var ExportCertificateResponse_Certificate *smithy.Schema + +var ExportCertificateResponse_CertificateChain *smithy.Schema + +var ExportCertificateResponse_PrivateKey *smithy.Schema + +var GetAccountConfigurationResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "GetAccountConfigurationResponse", +}, smithy.ShapeTypeStructure, 1) +var GetAccountConfigurationResponse_ExpiryEvents *smithy.Schema + +var GetAcmeExternalAccountBindingCredentialsRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "GetAcmeExternalAccountBindingCredentialsRequest", +}, smithy.ShapeTypeStructure, 1) +var GetAcmeExternalAccountBindingCredentialsRequest_AcmeExternalAccountBindingArn *smithy.Schema + +var GetAcmeExternalAccountBindingCredentialsResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "GetAcmeExternalAccountBindingCredentialsResponse", +}, smithy.ShapeTypeStructure, 2) +var GetAcmeExternalAccountBindingCredentialsResponse_KeyId *smithy.Schema + +var GetAcmeExternalAccountBindingCredentialsResponse_MacKey *smithy.Schema + +var GetCertificateRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "GetCertificateRequest", +}, smithy.ShapeTypeStructure, 1) +var GetCertificateRequest_CertificateArn *smithy.Schema + +var GetCertificateResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "GetCertificateResponse", +}, smithy.ShapeTypeStructure, 2) +var GetCertificateResponse_Certificate *smithy.Schema + +var GetCertificateResponse_CertificateChain *smithy.Schema + +var ImportCertificateRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ImportCertificateRequest", +}, smithy.ShapeTypeStructure, 5) +var ImportCertificateRequest_CertificateArn *smithy.Schema + +var ImportCertificateRequest_Certificate *smithy.Schema + +var ImportCertificateRequest_PrivateKey *smithy.Schema + +var ImportCertificateRequest_CertificateChain *smithy.Schema + +var ImportCertificateRequest_Tags *smithy.Schema + +var ImportCertificateResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ImportCertificateResponse", +}, smithy.ShapeTypeStructure, 1) +var ImportCertificateResponse_CertificateArn *smithy.Schema + +var ListAcmeAccountsRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListAcmeAccountsRequest", +}, smithy.ShapeTypeStructure, 3) +var ListAcmeAccountsRequest_NextToken *smithy.Schema + +var ListAcmeAccountsRequest_MaxResults *smithy.Schema + +var ListAcmeAccountsRequest_AcmeEndpointArn *smithy.Schema + +var ListAcmeAccountsResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListAcmeAccountsResponse", +}, smithy.ShapeTypeStructure, 2) +var ListAcmeAccountsResponse_AcmeAccounts *smithy.Schema + +var ListAcmeAccountsResponse_NextToken *smithy.Schema + +var ListAcmeDomainValidationsRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListAcmeDomainValidationsRequest", +}, smithy.ShapeTypeStructure, 3) +var ListAcmeDomainValidationsRequest_NextToken *smithy.Schema + +var ListAcmeDomainValidationsRequest_MaxResults *smithy.Schema + +var ListAcmeDomainValidationsRequest_AcmeEndpointArn *smithy.Schema + +var ListAcmeDomainValidationsResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListAcmeDomainValidationsResponse", +}, smithy.ShapeTypeStructure, 2) +var ListAcmeDomainValidationsResponse_AcmeDomainValidations *smithy.Schema + +var ListAcmeDomainValidationsResponse_NextToken *smithy.Schema + +var ListAcmeEndpointsRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListAcmeEndpointsRequest", +}, smithy.ShapeTypeStructure, 2) +var ListAcmeEndpointsRequest_NextToken *smithy.Schema + +var ListAcmeEndpointsRequest_MaxResults *smithy.Schema + +var ListAcmeEndpointsResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListAcmeEndpointsResponse", +}, smithy.ShapeTypeStructure, 2) +var ListAcmeEndpointsResponse_AcmeEndpoints *smithy.Schema + +var ListAcmeEndpointsResponse_NextToken *smithy.Schema + +var ListAcmeExternalAccountBindingsRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListAcmeExternalAccountBindingsRequest", +}, smithy.ShapeTypeStructure, 3) +var ListAcmeExternalAccountBindingsRequest_NextToken *smithy.Schema + +var ListAcmeExternalAccountBindingsRequest_MaxResults *smithy.Schema + +var ListAcmeExternalAccountBindingsRequest_AcmeEndpointArn *smithy.Schema + +var ListAcmeExternalAccountBindingsResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListAcmeExternalAccountBindingsResponse", +}, smithy.ShapeTypeStructure, 2) +var ListAcmeExternalAccountBindingsResponse_ExternalAccountBindings *smithy.Schema + +var ListAcmeExternalAccountBindingsResponse_NextToken *smithy.Schema + +var ListCertificateDomainValidationsRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListCertificateDomainValidationsRequest", +}, smithy.ShapeTypeStructure, 3) +var ListCertificateDomainValidationsRequest_CertificateArn *smithy.Schema + +var ListCertificateDomainValidationsRequest_NextToken *smithy.Schema + +var ListCertificateDomainValidationsRequest_MaxItems *smithy.Schema + +var ListCertificateDomainValidationsResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListCertificateDomainValidationsResponse", +}, smithy.ShapeTypeStructure, 2) +var ListCertificateDomainValidationsResponse_DomainValidationSummaryList *smithy.Schema + +var ListCertificateDomainValidationsResponse_NextToken *smithy.Schema + +var ListCertificatesRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListCertificatesRequest", +}, smithy.ShapeTypeStructure, 7) +var ListCertificatesRequest_CertificateStatuses *smithy.Schema + +var ListCertificatesRequest_CertificateKeyPairOrigins *smithy.Schema + +var ListCertificatesRequest_Includes *smithy.Schema + +var ListCertificatesRequest_NextToken *smithy.Schema + +var ListCertificatesRequest_MaxItems *smithy.Schema + +var ListCertificatesRequest_SortBy *smithy.Schema + +var ListCertificatesRequest_SortOrder *smithy.Schema + +var ListCertificatesResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListCertificatesResponse", +}, smithy.ShapeTypeStructure, 2) +var ListCertificatesResponse_NextToken *smithy.Schema + +var ListCertificatesResponse_CertificateSummaryList *smithy.Schema + +var ListTagsForCertificateRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListTagsForCertificateRequest", +}, smithy.ShapeTypeStructure, 1) +var ListTagsForCertificateRequest_CertificateArn *smithy.Schema + +var ListTagsForCertificateResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListTagsForCertificateResponse", +}, smithy.ShapeTypeStructure, 1) +var ListTagsForCertificateResponse_Tags *smithy.Schema + +var ListTagsForResourceRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListTagsForResourceRequest", +}, smithy.ShapeTypeStructure, 1) +var ListTagsForResourceRequest_ResourceArn *smithy.Schema + +var ListTagsForResourceResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ListTagsForResourceResponse", +}, smithy.ShapeTypeStructure, 1) +var ListTagsForResourceResponse_Tags *smithy.Schema + +var PutAccountConfigurationRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "PutAccountConfigurationRequest", +}, smithy.ShapeTypeStructure, 2) +var PutAccountConfigurationRequest_ExpiryEvents *smithy.Schema + +var PutAccountConfigurationRequest_IdempotencyToken *smithy.Schema + +var RemoveTagsFromCertificateRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RemoveTagsFromCertificateRequest", +}, smithy.ShapeTypeStructure, 2) +var RemoveTagsFromCertificateRequest_CertificateArn *smithy.Schema + +var RemoveTagsFromCertificateRequest_Tags *smithy.Schema + +var RenewCertificateRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RenewCertificateRequest", +}, smithy.ShapeTypeStructure, 1) +var RenewCertificateRequest_CertificateArn *smithy.Schema + +var RequestCertificateRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RequestCertificateRequest", +}, smithy.ShapeTypeStructure, 10) +var RequestCertificateRequest_DomainName *smithy.Schema + +var RequestCertificateRequest_ValidationMethod *smithy.Schema + +var RequestCertificateRequest_SubjectAlternativeNames *smithy.Schema + +var RequestCertificateRequest_IdempotencyToken *smithy.Schema + +var RequestCertificateRequest_DomainValidationOptions *smithy.Schema + +var RequestCertificateRequest_Options *smithy.Schema + +var RequestCertificateRequest_CertificateAuthorityArn *smithy.Schema + +var RequestCertificateRequest_Tags *smithy.Schema + +var RequestCertificateRequest_KeyAlgorithm *smithy.Schema + +var RequestCertificateRequest_ManagedBy *smithy.Schema + +var RequestCertificateResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RequestCertificateResponse", +}, smithy.ShapeTypeStructure, 1) +var RequestCertificateResponse_CertificateArn *smithy.Schema + +var ResendValidationEmailRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "ResendValidationEmailRequest", +}, smithy.ShapeTypeStructure, 3) +var ResendValidationEmailRequest_CertificateArn *smithy.Schema + +var ResendValidationEmailRequest_Domain *smithy.Schema + +var ResendValidationEmailRequest_ValidationDomain *smithy.Schema + +var RevokeAcmeAccountRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RevokeAcmeAccountRequest", +}, smithy.ShapeTypeStructure, 2) +var RevokeAcmeAccountRequest_AcmeEndpointArn *smithy.Schema + +var RevokeAcmeAccountRequest_AccountUrl *smithy.Schema + +var RevokeAcmeExternalAccountBindingRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RevokeAcmeExternalAccountBindingRequest", +}, smithy.ShapeTypeStructure, 1) +var RevokeAcmeExternalAccountBindingRequest_AcmeExternalAccountBindingArn *smithy.Schema + +var RevokeCertificateRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RevokeCertificateRequest", +}, smithy.ShapeTypeStructure, 2) +var RevokeCertificateRequest_CertificateArn *smithy.Schema + +var RevokeCertificateRequest_RevocationReason *smithy.Schema + +var RevokeCertificateResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "RevokeCertificateResponse", +}, smithy.ShapeTypeStructure, 1) +var RevokeCertificateResponse_CertificateArn *smithy.Schema + +var SearchCertificatesRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "SearchCertificatesRequest", +}, smithy.ShapeTypeStructure, 5) +var SearchCertificatesRequest_FilterStatement *smithy.Schema + +var SearchCertificatesRequest_MaxResults *smithy.Schema + +var SearchCertificatesRequest_NextToken *smithy.Schema + +var SearchCertificatesRequest_SortBy *smithy.Schema + +var SearchCertificatesRequest_SortOrder *smithy.Schema + +var SearchCertificatesResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "SearchCertificatesResponse", +}, smithy.ShapeTypeStructure, 2) +var SearchCertificatesResponse_Results *smithy.Schema + +var SearchCertificatesResponse_NextToken *smithy.Schema + +var TagResourceRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "TagResourceRequest", +}, smithy.ShapeTypeStructure, 2) +var TagResourceRequest_ResourceArn *smithy.Schema + +var TagResourceRequest_Tags *smithy.Schema + +var UntagResourceRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "UntagResourceRequest", +}, smithy.ShapeTypeStructure, 2) +var UntagResourceRequest_ResourceArn *smithy.Schema + +var UntagResourceRequest_TagKeys *smithy.Schema + +var UpdateAcmeDomainValidationRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "UpdateAcmeDomainValidationRequest", +}, smithy.ShapeTypeStructure, 2) +var UpdateAcmeDomainValidationRequest_AcmeDomainValidationArn *smithy.Schema + +var UpdateAcmeDomainValidationRequest_PrevalidationOptions *smithy.Schema + +var UpdateAcmeEndpointRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "UpdateAcmeEndpointRequest", +}, smithy.ShapeTypeStructure, 4) +var UpdateAcmeEndpointRequest_AcmeEndpointArn *smithy.Schema + +var UpdateAcmeEndpointRequest_AuthorizationBehavior *smithy.Schema + +var UpdateAcmeEndpointRequest_Contact *smithy.Schema + +var UpdateAcmeEndpointRequest_CertificateAuthority *smithy.Schema + +var UpdateCertificateOptionsRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.acm", + Name: "UpdateCertificateOptionsRequest", +}, smithy.ShapeTypeStructure, 2) +var UpdateCertificateOptionsRequest_CertificateArn *smithy.Schema + +var UpdateCertificateOptionsRequest_Options *smithy.Schema + +// Initialize schema members after all schemas are declared to avoid +// initialization cycles +func init() { + AccessDeniedException_Message = AccessDeniedException.AddMember("Message", _ServiceErrorMessage) + + RenewalEligibility_ELIGIBLE = RenewalEligibility.AddMember("ELIGIBLE", smithyprelude.Unit) + + RenewalEligibility_INELIGIBLE = RenewalEligibility.AddMember("INELIGIBLE", smithyprelude.Unit) + + CertificateStatus_PENDING_VALIDATION = CertificateStatus.AddMember("PENDING_VALIDATION", smithyprelude.Unit) + + CertificateStatus_ISSUED = CertificateStatus.AddMember("ISSUED", smithyprelude.Unit) + + CertificateStatus_INACTIVE = CertificateStatus.AddMember("INACTIVE", smithyprelude.Unit) + + CertificateStatus_EXPIRED = CertificateStatus.AddMember("EXPIRED", smithyprelude.Unit) + + CertificateStatus_VALIDATION_TIMED_OUT = CertificateStatus.AddMember("VALIDATION_TIMED_OUT", smithyprelude.Unit) + + CertificateStatus_REVOKED = CertificateStatus.AddMember("REVOKED", smithyprelude.Unit) + + CertificateStatus_FAILED = CertificateStatus.AddMember("FAILED", smithyprelude.Unit) + + RenewalStatus_PENDING_AUTO_RENEWAL = RenewalStatus.AddMember("PENDING_AUTO_RENEWAL", smithyprelude.Unit) + + RenewalStatus_PENDING_VALIDATION = RenewalStatus.AddMember("PENDING_VALIDATION", smithyprelude.Unit) + + RenewalStatus_SUCCESS = RenewalStatus.AddMember("SUCCESS", smithyprelude.Unit) + + RenewalStatus_FAILED = RenewalStatus.AddMember("FAILED", smithyprelude.Unit) + + CertificateType_IMPORTED = CertificateType.AddMember("IMPORTED", smithyprelude.Unit) + + CertificateType_AMAZON_ISSUED = CertificateType.AddMember("AMAZON_ISSUED", smithyprelude.Unit) + + CertificateType_PRIVATE = CertificateType.AddMember("PRIVATE", smithyprelude.Unit) + + CertificateExport_ENABLED = CertificateExport.AddMember("ENABLED", smithyprelude.Unit) + + CertificateExport_DISABLED = CertificateExport.AddMember("DISABLED", smithyprelude.Unit) + + CertificateManagedBy_CLOUDFRONT = CertificateManagedBy.AddMember("CLOUDFRONT", smithyprelude.Unit) + + ValidationMethod_EMAIL = ValidationMethod.AddMember("EMAIL", smithyprelude.Unit) + + ValidationMethod_DNS = ValidationMethod.AddMember("DNS", smithyprelude.Unit) + + ValidationMethod_HTTP = ValidationMethod.AddMember("HTTP", smithyprelude.Unit) + + CertificateKeyPairOrigin_AWS_MANAGED = CertificateKeyPairOrigin.AddMember("AWS_MANAGED", smithyprelude.Unit) + + CertificateKeyPairOrigin_ACME = CertificateKeyPairOrigin.AddMember("ACME", smithyprelude.Unit) + + CertificateKeyPairOrigin_CUSTOMER_PROVIDED = CertificateKeyPairOrigin.AddMember("CUSTOMER_PROVIDED", smithyprelude.Unit) + + AcmCertificateMetadata_CreatedAt = AcmCertificateMetadata.AddMember("CreatedAt", _TStamp) + + AcmCertificateMetadata_Exported = AcmCertificateMetadata.AddMember("Exported", _NullableBoolean) + + AcmCertificateMetadata_ImportedAt = AcmCertificateMetadata.AddMember("ImportedAt", _TStamp) + + AcmCertificateMetadata_InUse = AcmCertificateMetadata.AddMember("InUse", _NullableBoolean) + + AcmCertificateMetadata_IssuedAt = AcmCertificateMetadata.AddMember("IssuedAt", _TStamp) + + AcmCertificateMetadata_RenewalEligibility = AcmCertificateMetadata.AddMember("RenewalEligibility", RenewalEligibility) + + AcmCertificateMetadata_RevokedAt = AcmCertificateMetadata.AddMember("RevokedAt", _TStamp) + + AcmCertificateMetadata_Status = AcmCertificateMetadata.AddMember("Status", CertificateStatus) + + AcmCertificateMetadata_RenewalStatus = AcmCertificateMetadata.AddMember("RenewalStatus", RenewalStatus) + + AcmCertificateMetadata_Type = AcmCertificateMetadata.AddMember("Type", CertificateType) + + AcmCertificateMetadata_ExportOption = AcmCertificateMetadata.AddMember("ExportOption", CertificateExport) + + AcmCertificateMetadata_ManagedBy = AcmCertificateMetadata.AddMember("ManagedBy", CertificateManagedBy) + + AcmCertificateMetadata_ValidationMethod = AcmCertificateMetadata.AddMember("ValidationMethod", ValidationMethod) + + AcmCertificateMetadata_CertificateKeyPairOrigin = AcmCertificateMetadata.AddMember("CertificateKeyPairOrigin", CertificateKeyPairOrigin) + + AcmCertificateMetadata_AcmeEndpointArn = AcmCertificateMetadata.AddMember("AcmeEndpointArn", _Arn) + + AcmCertificateMetadata_AcmeAccountId = AcmCertificateMetadata.AddMember("AcmeAccountId", _AcmeAccountId) + + AcmCertificateMetadataFilter_Status = AcmCertificateMetadataFilter.AddMember("Status", CertificateStatus) + + AcmCertificateMetadataFilter_RenewalStatus = AcmCertificateMetadataFilter.AddMember("RenewalStatus", RenewalStatus) + + AcmCertificateMetadataFilter_Type = AcmCertificateMetadataFilter.AddMember("Type", CertificateType) + + AcmCertificateMetadataFilter_InUse = AcmCertificateMetadataFilter.AddMember("InUse", _NullableBoolean) + + AcmCertificateMetadataFilter_Exported = AcmCertificateMetadataFilter.AddMember("Exported", _NullableBoolean) + + AcmCertificateMetadataFilter_ExportOption = AcmCertificateMetadataFilter.AddMember("ExportOption", CertificateExport) + + AcmCertificateMetadataFilter_ManagedBy = AcmCertificateMetadataFilter.AddMember("ManagedBy", CertificateManagedBy) + + AcmCertificateMetadataFilter_ValidationMethod = AcmCertificateMetadataFilter.AddMember("ValidationMethod", ValidationMethod) + + AcmCertificateMetadataFilter_CertificateKeyPairOrigin = AcmCertificateMetadataFilter.AddMember("CertificateKeyPairOrigin", CertificateKeyPairOrigin) + + AcmCertificateMetadataFilter_AcmeEndpointArn = AcmCertificateMetadataFilter.AddMember("AcmeEndpointArn", _Arn) + + AcmCertificateMetadataFilter_AcmeAccountId = AcmCertificateMetadataFilter.AddMember("AcmeAccountId", _AcmeAccountId) + + AcmeAccountStatus_VALID = AcmeAccountStatus.AddMember("VALID", smithyprelude.Unit) + + AcmeAccountStatus_DEACTIVATED = AcmeAccountStatus.AddMember("DEACTIVATED", smithyprelude.Unit) + + AcmeAccountStatus_REVOKED = AcmeAccountStatus.AddMember("REVOKED", smithyprelude.Unit) + + _ContactList_member = _ContactList.AddMember("member", smithyprelude.String) + + AcmeAccount_AccountUrl = AcmeAccount.AddMember("AccountUrl", smithyprelude.String) + + AcmeAccount_PublicKeyThumbprint = AcmeAccount.AddMember("PublicKeyThumbprint", smithyprelude.String) + + AcmeAccount_Status = AcmeAccount.AddMember("Status", AcmeAccountStatus) + + AcmeAccount_CreatedAt = AcmeAccount.AddMember("CreatedAt", smithyprelude.Timestamp) + + AcmeAccount_AcmeExternalAccountBindingArn = AcmeAccount.AddMember("AcmeExternalAccountBindingArn", _AcmeExternalAccountBindingArn) + + AcmeAccount_Contacts = AcmeAccount.AddMember("Contacts", _ContactList) + + AcmeAccountSummary_AccountUrl = AcmeAccountSummary.AddMember("AccountUrl", smithyprelude.String) + + AcmeAccountSummary_PublicKeyThumbprint = AcmeAccountSummary.AddMember("PublicKeyThumbprint", smithyprelude.String) + + AcmeAccountSummary_Status = AcmeAccountSummary.AddMember("Status", AcmeAccountStatus) + + AcmeAccountSummary_CreatedAt = AcmeAccountSummary.AddMember("CreatedAt", smithyprelude.Timestamp) + + AcmeAccountSummary_AcmeExternalAccountBindingArn = AcmeAccountSummary.AddMember("AcmeExternalAccountBindingArn", _AcmeExternalAccountBindingArn) + + AcmeAccountSummary_Contacts = AcmeAccountSummary.AddMember("Contacts", _ContactList) + + _AcmeAccountList_member = _AcmeAccountList.AddMember("member", AcmeAccountSummary) + + AcmeAuthorizationBehavior_PRE_APPROVED = AcmeAuthorizationBehavior.AddMember("PRE_APPROVED", smithyprelude.Unit) + + AcmeContact_REQUIRED = AcmeContact.AddMember("REQUIRED", smithyprelude.Unit) + + AcmeContact_NOT_REQUIRED = AcmeContact.AddMember("NOT_REQUIRED", smithyprelude.Unit) + + PrevalidationType_DNS_PREVALIDATION = PrevalidationType.AddMember("DNS_PREVALIDATION", smithyprelude.Unit) + + DomainScopeOption_ENABLED = DomainScopeOption.AddMember("ENABLED", smithyprelude.Unit) + + DomainScopeOption_DISABLED = DomainScopeOption.AddMember("DISABLED", smithyprelude.Unit) + + DomainScope_ExactDomain = DomainScope.AddMember("ExactDomain", DomainScopeOption) + + DomainScope_Subdomains = DomainScope.AddMember("Subdomains", DomainScopeOption) + + DomainScope_Wildcards = DomainScope.AddMember("Wildcards", DomainScopeOption) + + RecordType_CNAME = RecordType.AddMember("CNAME", smithyprelude.Unit) + + ResourceRecord_Name = ResourceRecord.AddMember("Name", _String) + + ResourceRecord_Type = ResourceRecord.AddMember("Type", RecordType) + + ResourceRecord_Value = ResourceRecord.AddMember("Value", _String) + + DnsPrevalidationDetails_DomainScope = DnsPrevalidationDetails.AddMember("DomainScope", DomainScope) + + DnsPrevalidationDetails_HostedZoneId = DnsPrevalidationDetails.AddMember("HostedZoneId", _HostedZoneId) + + DnsPrevalidationDetails_ResourceRecord = DnsPrevalidationDetails.AddMember("ResourceRecord", ResourceRecord) + + PrevalidationDetails_DnsPrevalidation = PrevalidationDetails.AddMember("DnsPrevalidation", DnsPrevalidationDetails) + + AcmeDomainValidationStatus_VALIDATING = AcmeDomainValidationStatus.AddMember("VALIDATING", smithyprelude.Unit) + + AcmeDomainValidationStatus_VALID = AcmeDomainValidationStatus.AddMember("VALID", smithyprelude.Unit) + + AcmeDomainValidationStatus_INVALID = AcmeDomainValidationStatus.AddMember("INVALID", smithyprelude.Unit) + + AcmeDomainValidationStatus_DELETING = AcmeDomainValidationStatus.AddMember("DELETING", smithyprelude.Unit) + + AcmeDomainValidationFailureReason_ACCESS_DENIED = AcmeDomainValidationFailureReason.AddMember("ACCESS_DENIED", smithyprelude.Unit) + + AcmeDomainValidationFailureReason_DOMAIN_MISMATCH = AcmeDomainValidationFailureReason.AddMember("DOMAIN_MISMATCH", smithyprelude.Unit) + + AcmeDomainValidationFailureReason_DOMAIN_NOT_ALLOWED = AcmeDomainValidationFailureReason.AddMember("DOMAIN_NOT_ALLOWED", smithyprelude.Unit) + + AcmeDomainValidationFailureReason_ENDPOINT_NOT_ACTIVE = AcmeDomainValidationFailureReason.AddMember("ENDPOINT_NOT_ACTIVE", smithyprelude.Unit) + + AcmeDomainValidationFailureReason_HOSTED_ZONE_NOT_FOUND = AcmeDomainValidationFailureReason.AddMember("HOSTED_ZONE_NOT_FOUND", smithyprelude.Unit) + + AcmeDomainValidationFailureReason_INTERNAL_FAILURE = AcmeDomainValidationFailureReason.AddMember("INTERNAL_FAILURE", smithyprelude.Unit) + + AcmeDomainValidationFailureReason_INVALID_CHANGE_BATCH = AcmeDomainValidationFailureReason.AddMember("INVALID_CHANGE_BATCH", smithyprelude.Unit) + + AcmeDomainValidationFailureReason_INVALID_PUBLIC_DOMAIN = AcmeDomainValidationFailureReason.AddMember("INVALID_PUBLIC_DOMAIN", smithyprelude.Unit) + + AcmeDomainValidationFailureReason_TIMED_OUT = AcmeDomainValidationFailureReason.AddMember("TIMED_OUT", smithyprelude.Unit) + + FailureDetails_Reason = FailureDetails.AddMember("Reason", AcmeDomainValidationFailureReason) + + FailureDetails_Message = FailureDetails.AddMember("Message", smithyprelude.String) + + AcmeDomainValidation_AcmeDomainValidationArn = AcmeDomainValidation.AddMember("AcmeDomainValidationArn", _AcmeDomainValidationArn) + + AcmeDomainValidation_AcmeEndpointArn = AcmeDomainValidation.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + AcmeDomainValidation_DomainName = AcmeDomainValidation.AddMember("DomainName", _DomainName) + + AcmeDomainValidation_PrevalidationType = AcmeDomainValidation.AddMember("PrevalidationType", PrevalidationType) + + AcmeDomainValidation_PrevalidationDetails = AcmeDomainValidation.AddMember("PrevalidationDetails", PrevalidationDetails) + + AcmeDomainValidation_Status = AcmeDomainValidation.AddMember("Status", AcmeDomainValidationStatus) + + AcmeDomainValidation_FailureDetails = AcmeDomainValidation.AddMember("FailureDetails", FailureDetails) + + AcmeDomainValidation_CreatedAt = AcmeDomainValidation.AddMember("CreatedAt", smithyprelude.Timestamp) + + AcmeDomainValidation_UpdatedAt = AcmeDomainValidation.AddMember("UpdatedAt", smithyprelude.Timestamp) + + AcmeDomainValidationSummary_AcmeDomainValidationArn = AcmeDomainValidationSummary.AddMember("AcmeDomainValidationArn", _AcmeDomainValidationArn) + + AcmeDomainValidationSummary_AcmeEndpointArn = AcmeDomainValidationSummary.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + AcmeDomainValidationSummary_DomainName = AcmeDomainValidationSummary.AddMember("DomainName", _DomainName) + + AcmeDomainValidationSummary_PrevalidationType = AcmeDomainValidationSummary.AddMember("PrevalidationType", PrevalidationType) + + AcmeDomainValidationSummary_PrevalidationDetails = AcmeDomainValidationSummary.AddMember("PrevalidationDetails", PrevalidationDetails) + + AcmeDomainValidationSummary_Status = AcmeDomainValidationSummary.AddMember("Status", AcmeDomainValidationStatus) + + AcmeDomainValidationSummary_FailureDetails = AcmeDomainValidationSummary.AddMember("FailureDetails", FailureDetails) + + AcmeDomainValidationSummary_CreatedAt = AcmeDomainValidationSummary.AddMember("CreatedAt", smithyprelude.Timestamp) + + AcmeDomainValidationSummary_UpdatedAt = AcmeDomainValidationSummary.AddMember("UpdatedAt", smithyprelude.Timestamp) + + _AcmeDomainValidationList_member = _AcmeDomainValidationList.AddMember("member", AcmeDomainValidationSummary) + + AcmeEndpointStatus_CREATING = AcmeEndpointStatus.AddMember("CREATING", smithyprelude.Unit) + + AcmeEndpointStatus_ACTIVE = AcmeEndpointStatus.AddMember("ACTIVE", smithyprelude.Unit) + + AcmeEndpointStatus_DELETING = AcmeEndpointStatus.AddMember("DELETING", smithyprelude.Unit) + + AcmeEndpointStatus_FAILED = AcmeEndpointStatus.AddMember("FAILED", smithyprelude.Unit) + + PublicKeyAlgorithm_RSA_2048 = PublicKeyAlgorithm.AddMember("RSA_2048", smithyprelude.Unit) + + PublicKeyAlgorithm_EC_PRIME256_V1 = PublicKeyAlgorithm.AddMember("EC_PRIME256_V1", smithyprelude.Unit) + + PublicKeyAlgorithm_EC_SECP384_R1 = PublicKeyAlgorithm.AddMember("EC_SECP384_R1", smithyprelude.Unit) + + _PublicKeyAlgorithmList_member = _PublicKeyAlgorithmList.AddMember("member", PublicKeyAlgorithm) + + PublicCertificateAuthority_AllowedKeyAlgorithms = PublicCertificateAuthority.AddMember("AllowedKeyAlgorithms", _PublicKeyAlgorithmList) + + CertificateAuthority_PublicCertificateAuthority = CertificateAuthority.AddMember("PublicCertificateAuthority", PublicCertificateAuthority) + + Tag_Key = Tag.AddMember("Key", _TagKey) + + Tag_Value = Tag.AddMember("Value", _TagValue) + + _TagList_member = _TagList.AddMember("member", Tag) + + AcmeEndpoint_AcmeEndpointArn = AcmeEndpoint.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + AcmeEndpoint_EndpointUrl = AcmeEndpoint.AddMember("EndpointUrl", smithyprelude.String) + + AcmeEndpoint_Status = AcmeEndpoint.AddMember("Status", AcmeEndpointStatus) + + AcmeEndpoint_FailureReason = AcmeEndpoint.AddMember("FailureReason", smithyprelude.String) + + AcmeEndpoint_AuthorizationBehavior = AcmeEndpoint.AddMember("AuthorizationBehavior", AcmeAuthorizationBehavior) + + AcmeEndpoint_Contact = AcmeEndpoint.AddMember("Contact", AcmeContact) + + AcmeEndpoint_CertificateAuthority = AcmeEndpoint.AddMember("CertificateAuthority", CertificateAuthority) + + AcmeEndpoint_CertificateTags = AcmeEndpoint.AddMember("CertificateTags", _TagList) + + AcmeEndpoint_CreatedAt = AcmeEndpoint.AddMember("CreatedAt", smithyprelude.Timestamp) + + AcmeEndpoint_UpdatedAt = AcmeEndpoint.AddMember("UpdatedAt", smithyprelude.Timestamp) + + AcmeEndpointSummary_AcmeEndpointArn = AcmeEndpointSummary.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + AcmeEndpointSummary_EndpointUrl = AcmeEndpointSummary.AddMember("EndpointUrl", smithyprelude.String) + + AcmeEndpointSummary_Status = AcmeEndpointSummary.AddMember("Status", AcmeEndpointStatus) + + AcmeEndpointSummary_FailureReason = AcmeEndpointSummary.AddMember("FailureReason", smithyprelude.String) + + AcmeEndpointSummary_AuthorizationBehavior = AcmeEndpointSummary.AddMember("AuthorizationBehavior", AcmeAuthorizationBehavior) + + AcmeEndpointSummary_Contact = AcmeEndpointSummary.AddMember("Contact", AcmeContact) + + AcmeEndpointSummary_CertificateAuthority = AcmeEndpointSummary.AddMember("CertificateAuthority", CertificateAuthority) + + AcmeEndpointSummary_CertificateTags = AcmeEndpointSummary.AddMember("CertificateTags", _TagList) + + AcmeEndpointSummary_CreatedAt = AcmeEndpointSummary.AddMember("CreatedAt", smithyprelude.Timestamp) + + AcmeEndpointSummary_UpdatedAt = AcmeEndpointSummary.AddMember("UpdatedAt", smithyprelude.Timestamp) + + _AcmeEndpointList_member = _AcmeEndpointList.AddMember("member", AcmeEndpointSummary) + + AcmeExternalAccountBinding_AcmeExternalAccountBindingArn = AcmeExternalAccountBinding.AddMember("AcmeExternalAccountBindingArn", _AcmeExternalAccountBindingArn) + + AcmeExternalAccountBinding_AcmeEndpointArn = AcmeExternalAccountBinding.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + AcmeExternalAccountBinding_RoleArn = AcmeExternalAccountBinding.AddMember("RoleArn", _RoleArn) + + AcmeExternalAccountBinding_ExpiresAt = AcmeExternalAccountBinding.AddMember("ExpiresAt", smithyprelude.Timestamp) + + AcmeExternalAccountBinding_RevokedAt = AcmeExternalAccountBinding.AddMember("RevokedAt", smithyprelude.Timestamp) + + AcmeExternalAccountBinding_LastUsedAt = AcmeExternalAccountBinding.AddMember("LastUsedAt", smithyprelude.Timestamp) + + AcmeExternalAccountBinding_CreatedAt = AcmeExternalAccountBinding.AddMember("CreatedAt", smithyprelude.Timestamp) + + AcmeExternalAccountBinding_UpdatedAt = AcmeExternalAccountBinding.AddMember("UpdatedAt", smithyprelude.Timestamp) + + AcmeExternalAccountBindingSummary_AcmeExternalAccountBindingArn = AcmeExternalAccountBindingSummary.AddMember("AcmeExternalAccountBindingArn", _AcmeExternalAccountBindingArn) + + AcmeExternalAccountBindingSummary_AcmeEndpointArn = AcmeExternalAccountBindingSummary.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + AcmeExternalAccountBindingSummary_RoleArn = AcmeExternalAccountBindingSummary.AddMember("RoleArn", _RoleArn) + + AcmeExternalAccountBindingSummary_ExpiresAt = AcmeExternalAccountBindingSummary.AddMember("ExpiresAt", smithyprelude.Timestamp) + + AcmeExternalAccountBindingSummary_RevokedAt = AcmeExternalAccountBindingSummary.AddMember("RevokedAt", smithyprelude.Timestamp) + + AcmeExternalAccountBindingSummary_LastUsedAt = AcmeExternalAccountBindingSummary.AddMember("LastUsedAt", smithyprelude.Timestamp) + + AcmeExternalAccountBindingSummary_CreatedAt = AcmeExternalAccountBindingSummary.AddMember("CreatedAt", smithyprelude.Timestamp) + + AcmeExternalAccountBindingSummary_UpdatedAt = AcmeExternalAccountBindingSummary.AddMember("UpdatedAt", smithyprelude.Timestamp) + + _AcmeExternalAccountBindingList_member = _AcmeExternalAccountBindingList.AddMember("member", AcmeExternalAccountBindingSummary) + + _DomainList_member = _DomainList.AddMember("member", _DomainNameString) + + _ValidationEmailList_member = _ValidationEmailList.AddMember("member", _String) + + DomainStatus_PENDING_VALIDATION = DomainStatus.AddMember("PENDING_VALIDATION", smithyprelude.Unit) + + DomainStatus_SUCCESS = DomainStatus.AddMember("SUCCESS", smithyprelude.Unit) + + DomainStatus_FAILED = DomainStatus.AddMember("FAILED", smithyprelude.Unit) + + HttpRedirect_RedirectFrom = HttpRedirect.AddMember("RedirectFrom", _String) + + HttpRedirect_RedirectTo = HttpRedirect.AddMember("RedirectTo", _String) + + DomainValidation_DomainName = DomainValidation.AddMember("DomainName", _DomainNameString) + + DomainValidation_ValidationEmails = DomainValidation.AddMember("ValidationEmails", _ValidationEmailList) + + DomainValidation_ValidationDomain = DomainValidation.AddMember("ValidationDomain", _DomainNameString) + + DomainValidation_ValidationStatus = DomainValidation.AddMember("ValidationStatus", DomainStatus) + + DomainValidation_ResourceRecord = DomainValidation.AddMember("ResourceRecord", ResourceRecord) + + DomainValidation_HttpRedirect = DomainValidation.AddMember("HttpRedirect", HttpRedirect) + + DomainValidation_ValidationMethod = DomainValidation.AddMember("ValidationMethod", ValidationMethod) + + _DomainValidationList_member = _DomainValidationList.AddMember("member", DomainValidation) + + RevocationReason_UNSPECIFIED = RevocationReason.AddMember("UNSPECIFIED", smithyprelude.Unit) + + RevocationReason_KEY_COMPROMISE = RevocationReason.AddMember("KEY_COMPROMISE", smithyprelude.Unit) + + RevocationReason_CA_COMPROMISE = RevocationReason.AddMember("CA_COMPROMISE", smithyprelude.Unit) + + RevocationReason_AFFILIATION_CHANGED = RevocationReason.AddMember("AFFILIATION_CHANGED", smithyprelude.Unit) + + RevocationReason_SUPERCEDED = RevocationReason.AddMember("SUPERCEDED", smithyprelude.Unit) + + RevocationReason_SUPERSEDED = RevocationReason.AddMember("SUPERSEDED", smithyprelude.Unit) + + RevocationReason_CESSATION_OF_OPERATION = RevocationReason.AddMember("CESSATION_OF_OPERATION", smithyprelude.Unit) + + RevocationReason_CERTIFICATE_HOLD = RevocationReason.AddMember("CERTIFICATE_HOLD", smithyprelude.Unit) + + RevocationReason_REMOVE_FROM_CRL = RevocationReason.AddMember("REMOVE_FROM_CRL", smithyprelude.Unit) + + RevocationReason_PRIVILEGE_WITHDRAWN = RevocationReason.AddMember("PRIVILEGE_WITHDRAWN", smithyprelude.Unit) + + RevocationReason_A_A_COMPROMISE = RevocationReason.AddMember("A_A_COMPROMISE", smithyprelude.Unit) + + KeyAlgorithm_RSA_1024 = KeyAlgorithm.AddMember("RSA_1024", smithyprelude.Unit) + + KeyAlgorithm_RSA_2048 = KeyAlgorithm.AddMember("RSA_2048", smithyprelude.Unit) + + KeyAlgorithm_RSA_3072 = KeyAlgorithm.AddMember("RSA_3072", smithyprelude.Unit) + + KeyAlgorithm_RSA_4096 = KeyAlgorithm.AddMember("RSA_4096", smithyprelude.Unit) + + KeyAlgorithm_EC_prime256v1 = KeyAlgorithm.AddMember("EC_prime256v1", smithyprelude.Unit) + + KeyAlgorithm_EC_secp384r1 = KeyAlgorithm.AddMember("EC_secp384r1", smithyprelude.Unit) + + KeyAlgorithm_EC_secp521r1 = KeyAlgorithm.AddMember("EC_secp521r1", smithyprelude.Unit) + + _InUseList_member = _InUseList.AddMember("member", _String) + + FailureReason_NO_AVAILABLE_CONTACTS = FailureReason.AddMember("NO_AVAILABLE_CONTACTS", smithyprelude.Unit) + + FailureReason_ADDITIONAL_VERIFICATION_REQUIRED = FailureReason.AddMember("ADDITIONAL_VERIFICATION_REQUIRED", smithyprelude.Unit) + + FailureReason_DOMAIN_NOT_ALLOWED = FailureReason.AddMember("DOMAIN_NOT_ALLOWED", smithyprelude.Unit) + + FailureReason_INVALID_PUBLIC_DOMAIN = FailureReason.AddMember("INVALID_PUBLIC_DOMAIN", smithyprelude.Unit) + + FailureReason_DOMAIN_VALIDATION_DENIED = FailureReason.AddMember("DOMAIN_VALIDATION_DENIED", smithyprelude.Unit) + + FailureReason_CAA_ERROR = FailureReason.AddMember("CAA_ERROR", smithyprelude.Unit) + + FailureReason_PCA_LIMIT_EXCEEDED = FailureReason.AddMember("PCA_LIMIT_EXCEEDED", smithyprelude.Unit) + + FailureReason_PCA_INVALID_ARN = FailureReason.AddMember("PCA_INVALID_ARN", smithyprelude.Unit) + + FailureReason_PCA_INVALID_STATE = FailureReason.AddMember("PCA_INVALID_STATE", smithyprelude.Unit) + + FailureReason_PCA_REQUEST_FAILED = FailureReason.AddMember("PCA_REQUEST_FAILED", smithyprelude.Unit) + + FailureReason_PCA_NAME_CONSTRAINTS_VALIDATION = FailureReason.AddMember("PCA_NAME_CONSTRAINTS_VALIDATION", smithyprelude.Unit) + + FailureReason_PCA_RESOURCE_NOT_FOUND = FailureReason.AddMember("PCA_RESOURCE_NOT_FOUND", smithyprelude.Unit) + + FailureReason_PCA_INVALID_ARGS = FailureReason.AddMember("PCA_INVALID_ARGS", smithyprelude.Unit) + + FailureReason_PCA_INVALID_DURATION = FailureReason.AddMember("PCA_INVALID_DURATION", smithyprelude.Unit) + + FailureReason_PCA_ACCESS_DENIED = FailureReason.AddMember("PCA_ACCESS_DENIED", smithyprelude.Unit) + + FailureReason_SLR_NOT_FOUND = FailureReason.AddMember("SLR_NOT_FOUND", smithyprelude.Unit) + + FailureReason_OTHER = FailureReason.AddMember("OTHER", smithyprelude.Unit) + + RenewalSummary_RenewalStatus = RenewalSummary.AddMember("RenewalStatus", RenewalStatus) + + RenewalSummary_DomainValidationOptions = RenewalSummary.AddMember("DomainValidationOptions", _DomainValidationList) + + RenewalSummary_RenewalStatusReason = RenewalSummary.AddMember("RenewalStatusReason", FailureReason) + + RenewalSummary_UpdatedAt = RenewalSummary.AddMember("UpdatedAt", _TStamp) + + KeyUsageName_DIGITAL_SIGNATURE = KeyUsageName.AddMember("DIGITAL_SIGNATURE", smithyprelude.Unit) + + KeyUsageName_NON_REPUDATION = KeyUsageName.AddMember("NON_REPUDATION", smithyprelude.Unit) + + KeyUsageName_KEY_ENCIPHERMENT = KeyUsageName.AddMember("KEY_ENCIPHERMENT", smithyprelude.Unit) + + KeyUsageName_DATA_ENCIPHERMENT = KeyUsageName.AddMember("DATA_ENCIPHERMENT", smithyprelude.Unit) + + KeyUsageName_KEY_AGREEMENT = KeyUsageName.AddMember("KEY_AGREEMENT", smithyprelude.Unit) + + KeyUsageName_CERTIFICATE_SIGNING = KeyUsageName.AddMember("CERTIFICATE_SIGNING", smithyprelude.Unit) + + KeyUsageName_CRL_SIGNING = KeyUsageName.AddMember("CRL_SIGNING", smithyprelude.Unit) + + KeyUsageName_ENCHIPER_ONLY = KeyUsageName.AddMember("ENCHIPER_ONLY", smithyprelude.Unit) + + KeyUsageName_DECIPHER_ONLY = KeyUsageName.AddMember("DECIPHER_ONLY", smithyprelude.Unit) + + KeyUsageName_ANY = KeyUsageName.AddMember("ANY", smithyprelude.Unit) + + KeyUsageName_CUSTOM = KeyUsageName.AddMember("CUSTOM", smithyprelude.Unit) + + KeyUsage_Name = KeyUsage.AddMember("Name", KeyUsageName) + + _KeyUsageList_member = _KeyUsageList.AddMember("member", KeyUsage) + + ExtendedKeyUsageName_TLS_WEB_SERVER_AUTHENTICATION = ExtendedKeyUsageName.AddMember("TLS_WEB_SERVER_AUTHENTICATION", smithyprelude.Unit) + + ExtendedKeyUsageName_TLS_WEB_CLIENT_AUTHENTICATION = ExtendedKeyUsageName.AddMember("TLS_WEB_CLIENT_AUTHENTICATION", smithyprelude.Unit) + + ExtendedKeyUsageName_CODE_SIGNING = ExtendedKeyUsageName.AddMember("CODE_SIGNING", smithyprelude.Unit) + + ExtendedKeyUsageName_EMAIL_PROTECTION = ExtendedKeyUsageName.AddMember("EMAIL_PROTECTION", smithyprelude.Unit) + + ExtendedKeyUsageName_TIME_STAMPING = ExtendedKeyUsageName.AddMember("TIME_STAMPING", smithyprelude.Unit) + + ExtendedKeyUsageName_OCSP_SIGNING = ExtendedKeyUsageName.AddMember("OCSP_SIGNING", smithyprelude.Unit) + + ExtendedKeyUsageName_IPSEC_END_SYSTEM = ExtendedKeyUsageName.AddMember("IPSEC_END_SYSTEM", smithyprelude.Unit) + + ExtendedKeyUsageName_IPSEC_TUNNEL = ExtendedKeyUsageName.AddMember("IPSEC_TUNNEL", smithyprelude.Unit) + + ExtendedKeyUsageName_IPSEC_USER = ExtendedKeyUsageName.AddMember("IPSEC_USER", smithyprelude.Unit) + + ExtendedKeyUsageName_ANY = ExtendedKeyUsageName.AddMember("ANY", smithyprelude.Unit) + + ExtendedKeyUsageName_NONE = ExtendedKeyUsageName.AddMember("NONE", smithyprelude.Unit) + + ExtendedKeyUsageName_CUSTOM = ExtendedKeyUsageName.AddMember("CUSTOM", smithyprelude.Unit) + + ExtendedKeyUsage_Name = ExtendedKeyUsage.AddMember("Name", ExtendedKeyUsageName) + + ExtendedKeyUsage_OID = ExtendedKeyUsage.AddMember("OID", _String) + + _ExtendedKeyUsageList_member = _ExtendedKeyUsageList.AddMember("member", ExtendedKeyUsage) + + CertificateTransparencyLoggingPreference_ENABLED = CertificateTransparencyLoggingPreference.AddMember("ENABLED", smithyprelude.Unit) + + CertificateTransparencyLoggingPreference_DISABLED = CertificateTransparencyLoggingPreference.AddMember("DISABLED", smithyprelude.Unit) + + CertificateOptions_CertificateTransparencyLoggingPreference = CertificateOptions.AddMember("CertificateTransparencyLoggingPreference", CertificateTransparencyLoggingPreference) + + CertificateOptions_Export = CertificateOptions.AddMember("Export", CertificateExport) + + CertificateOptions_ValidationMethod = CertificateOptions.AddMember("ValidationMethod", ValidationMethod) + + UpdateStatus_PENDING_DOMAIN_VALIDATION = UpdateStatus.AddMember("PENDING_DOMAIN_VALIDATION", smithyprelude.Unit) + + UpdateStatus_SUCCESS = UpdateStatus.AddMember("SUCCESS", smithyprelude.Unit) + + UpdateStatus_FAILED = UpdateStatus.AddMember("FAILED", smithyprelude.Unit) + + UpdateType_DOMAIN_VALIDATION_METHOD = UpdateType.AddMember("DOMAIN_VALIDATION_METHOD", smithyprelude.Unit) + + DomainValidationMethodUpdateSummary_From = DomainValidationMethodUpdateSummary.AddMember("From", ValidationMethod) + + DomainValidationMethodUpdateSummary_To = DomainValidationMethodUpdateSummary.AddMember("To", ValidationMethod) + + UpdateSummary_Status = UpdateSummary.AddMember("Status", UpdateStatus) + + UpdateSummary_Type = UpdateSummary.AddMember("Type", UpdateType) + + UpdateSummary_DomainValidationMethodUpdateSummary = UpdateSummary.AddMember("DomainValidationMethodUpdateSummary", DomainValidationMethodUpdateSummary) + + UpdateSummary_RequestedAt = UpdateSummary.AddMember("RequestedAt", _TStamp) + + UpdateSummary_UpdatedAt = UpdateSummary.AddMember("UpdatedAt", _TStamp) + + CertificateDetail_CertificateArn = CertificateDetail.AddMember("CertificateArn", _Arn) + + CertificateDetail_DomainName = CertificateDetail.AddMember("DomainName", _DomainNameString) + + CertificateDetail_SubjectAlternativeNames = CertificateDetail.AddMember("SubjectAlternativeNames", _DomainList) + + CertificateDetail_ManagedBy = CertificateDetail.AddMember("ManagedBy", CertificateManagedBy) + + CertificateDetail_DomainValidationOptions = CertificateDetail.AddMember("DomainValidationOptions", _DomainValidationList) + + CertificateDetail_Serial = CertificateDetail.AddMember("Serial", _String) + + CertificateDetail_Subject = CertificateDetail.AddMember("Subject", _String) + + CertificateDetail_Issuer = CertificateDetail.AddMember("Issuer", _String) + + CertificateDetail_CreatedAt = CertificateDetail.AddMember("CreatedAt", _TStamp) + + CertificateDetail_IssuedAt = CertificateDetail.AddMember("IssuedAt", _TStamp) + + CertificateDetail_ImportedAt = CertificateDetail.AddMember("ImportedAt", _TStamp) + + CertificateDetail_Status = CertificateDetail.AddMember("Status", CertificateStatus) + + CertificateDetail_RevokedAt = CertificateDetail.AddMember("RevokedAt", _TStamp) + + CertificateDetail_RevocationReason = CertificateDetail.AddMember("RevocationReason", RevocationReason) + + CertificateDetail_NotBefore = CertificateDetail.AddMember("NotBefore", _TStamp) + + CertificateDetail_NotAfter = CertificateDetail.AddMember("NotAfter", _TStamp) + + CertificateDetail_KeyAlgorithm = CertificateDetail.AddMember("KeyAlgorithm", KeyAlgorithm) + + CertificateDetail_SignatureAlgorithm = CertificateDetail.AddMember("SignatureAlgorithm", _String) + + CertificateDetail_InUseBy = CertificateDetail.AddMember("InUseBy", _InUseList) + + CertificateDetail_FailureReason = CertificateDetail.AddMember("FailureReason", FailureReason) + + CertificateDetail_Type = CertificateDetail.AddMember("Type", CertificateType) + + CertificateDetail_RenewalSummary = CertificateDetail.AddMember("RenewalSummary", RenewalSummary) + + CertificateDetail_KeyUsages = CertificateDetail.AddMember("KeyUsages", _KeyUsageList) + + CertificateDetail_ExtendedKeyUsages = CertificateDetail.AddMember("ExtendedKeyUsages", _ExtendedKeyUsageList) + + CertificateDetail_CertificateAuthorityArn = CertificateDetail.AddMember("CertificateAuthorityArn", _Arn) + + CertificateDetail_RenewalEligibility = CertificateDetail.AddMember("RenewalEligibility", RenewalEligibility) + + CertificateDetail_Options = CertificateDetail.AddMember("Options", CertificateOptions) + + CertificateDetail_UpdateSummary = CertificateDetail.AddMember("UpdateSummary", UpdateSummary) + + CertificateDetail_CertificateKeyPairOrigin = CertificateDetail.AddMember("CertificateKeyPairOrigin", CertificateKeyPairOrigin) + + CertificateDetail_AcmeEndpointArn = CertificateDetail.AddMember("AcmeEndpointArn", _Arn) + + CertificateDetail_AcmeAccountId = CertificateDetail.AddMember("AcmeAccountId", _AcmeAccountId) + + ComparisonOperator_CONTAINS = ComparisonOperator.AddMember("CONTAINS", smithyprelude.Unit) + + ComparisonOperator_EQUALS = ComparisonOperator.AddMember("EQUALS", smithyprelude.Unit) + + CommonNameFilter_Value = CommonNameFilter.AddMember("Value", _FilterString) + + CommonNameFilter_ComparisonOperator = CommonNameFilter.AddMember("ComparisonOperator", ComparisonOperator) + + SubjectFilter_CommonName = SubjectFilter.AddMember("CommonName", CommonNameFilter) + + DnsNameFilter_Value = DnsNameFilter.AddMember("Value", _FilterString) + + DnsNameFilter_ComparisonOperator = DnsNameFilter.AddMember("ComparisonOperator", ComparisonOperator) + + SubjectAlternativeNameFilter_DnsName = SubjectAlternativeNameFilter.AddMember("DnsName", DnsNameFilter) + + TimestampRange_Start = TimestampRange.AddMember("Start", _TStamp) + + TimestampRange_End = TimestampRange.AddMember("End", _TStamp) + + X509AttributeFilter_Subject = X509AttributeFilter.AddMember("Subject", SubjectFilter) + + X509AttributeFilter_SubjectAlternativeName = X509AttributeFilter.AddMember("SubjectAlternativeName", SubjectAlternativeNameFilter) + + X509AttributeFilter_ExtendedKeyUsage = X509AttributeFilter.AddMember("ExtendedKeyUsage", ExtendedKeyUsageName) + + X509AttributeFilter_KeyUsage = X509AttributeFilter.AddMember("KeyUsage", KeyUsageName) + + X509AttributeFilter_KeyAlgorithm = X509AttributeFilter.AddMember("KeyAlgorithm", KeyAlgorithm) + + X509AttributeFilter_SerialNumber = X509AttributeFilter.AddMember("SerialNumber", _SerialNumber) + + X509AttributeFilter_NotAfter = X509AttributeFilter.AddMember("NotAfter", TimestampRange) + + X509AttributeFilter_NotBefore = X509AttributeFilter.AddMember("NotBefore", TimestampRange) + + CertificateFilter_CertificateArn = CertificateFilter.AddMember("CertificateArn", _Arn) + + CertificateFilter_X509AttributeFilter = CertificateFilter.AddMember("X509AttributeFilter", X509AttributeFilter) + + CertificateFilter_AcmCertificateMetadataFilter = CertificateFilter.AddMember("AcmCertificateMetadataFilter", AcmCertificateMetadataFilter) + + _CertificateFilterStatementList_member = _CertificateFilterStatementList.AddMember("member", CertificateFilterStatement) + + CertificateFilterStatement_And = CertificateFilterStatement.AddMember("And", _CertificateFilterStatementList) + + CertificateFilterStatement_Or = CertificateFilterStatement.AddMember("Or", _CertificateFilterStatementList) + + CertificateFilterStatement_Not = CertificateFilterStatement.AddMember("Not", CertificateFilterStatement) + + CertificateFilterStatement_Filter = CertificateFilterStatement.AddMember("Filter", CertificateFilter) + + _CertificateKeyPairOrigins_member = _CertificateKeyPairOrigins.AddMember("member", CertificateKeyPairOrigin) + + CertificateMetadata_AcmCertificateMetadata = CertificateMetadata.AddMember("AcmCertificateMetadata", AcmCertificateMetadata) + + _DomainComponentList_member = _DomainComponentList.AddMember("member", _String) + + CustomAttribute_ObjectIdentifier = CustomAttribute.AddMember("ObjectIdentifier", _String) + + CustomAttribute_Value = CustomAttribute.AddMember("Value", _String) + + _CustomAttributeList_member = _CustomAttributeList.AddMember("member", CustomAttribute) + + DistinguishedName_CommonName = DistinguishedName.AddMember("CommonName", _String) + + DistinguishedName_DomainComponents = DistinguishedName.AddMember("DomainComponents", _DomainComponentList) + + DistinguishedName_Country = DistinguishedName.AddMember("Country", _String) + + DistinguishedName_CustomAttributes = DistinguishedName.AddMember("CustomAttributes", _CustomAttributeList) + + DistinguishedName_DistinguishedNameQualifier = DistinguishedName.AddMember("DistinguishedNameQualifier", _String) + + DistinguishedName_GenerationQualifier = DistinguishedName.AddMember("GenerationQualifier", _String) + + DistinguishedName_GivenName = DistinguishedName.AddMember("GivenName", _String) + + DistinguishedName_Initials = DistinguishedName.AddMember("Initials", _String) + + DistinguishedName_Locality = DistinguishedName.AddMember("Locality", _String) + + DistinguishedName_Organization = DistinguishedName.AddMember("Organization", _String) + + DistinguishedName_OrganizationalUnit = DistinguishedName.AddMember("OrganizationalUnit", _String) + + DistinguishedName_Pseudonym = DistinguishedName.AddMember("Pseudonym", _String) + + DistinguishedName_SerialNumber = DistinguishedName.AddMember("SerialNumber", _String) + + DistinguishedName_State = DistinguishedName.AddMember("State", _String) + + DistinguishedName_Surname = DistinguishedName.AddMember("Surname", _String) + + DistinguishedName_Title = DistinguishedName.AddMember("Title", _String) + + OtherName_ObjectIdentifier = OtherName.AddMember("ObjectIdentifier", _String) + + OtherName_Value = OtherName.AddMember("Value", _String) + + GeneralName_DirectoryName = GeneralName.AddMember("DirectoryName", DistinguishedName) + + GeneralName_DnsName = GeneralName.AddMember("DnsName", _String) + + GeneralName_IpAddress = GeneralName.AddMember("IpAddress", _String) + + GeneralName_OtherName = GeneralName.AddMember("OtherName", OtherName) + + GeneralName_RegisteredId = GeneralName.AddMember("RegisteredId", _String) + + GeneralName_Rfc822Name = GeneralName.AddMember("Rfc822Name", _String) + + GeneralName_UniformResourceIdentifier = GeneralName.AddMember("UniformResourceIdentifier", _String) + + _GeneralNameList_member = _GeneralNameList.AddMember("member", GeneralName) + + _ExtendedKeyUsageNames_member = _ExtendedKeyUsageNames.AddMember("member", ExtendedKeyUsageName) + + _KeyUsageNames_member = _KeyUsageNames.AddMember("member", KeyUsageName) + + X509Attributes_Issuer = X509Attributes.AddMember("Issuer", DistinguishedName) + + X509Attributes_Subject = X509Attributes.AddMember("Subject", DistinguishedName) + + X509Attributes_SubjectAlternativeNames = X509Attributes.AddMember("SubjectAlternativeNames", _GeneralNameList) + + X509Attributes_ExtendedKeyUsages = X509Attributes.AddMember("ExtendedKeyUsages", _ExtendedKeyUsageNames) + + X509Attributes_KeyAlgorithm = X509Attributes.AddMember("KeyAlgorithm", KeyAlgorithm) + + X509Attributes_KeyUsages = X509Attributes.AddMember("KeyUsages", _KeyUsageNames) + + X509Attributes_SerialNumber = X509Attributes.AddMember("SerialNumber", _SerialNumber) + + X509Attributes_NotAfter = X509Attributes.AddMember("NotAfter", _TStamp) + + X509Attributes_NotBefore = X509Attributes.AddMember("NotBefore", _TStamp) + + CertificateSearchResult_CertificateArn = CertificateSearchResult.AddMember("CertificateArn", _Arn) + + CertificateSearchResult_X509Attributes = CertificateSearchResult.AddMember("X509Attributes", X509Attributes) + + CertificateSearchResult_CertificateMetadata = CertificateSearchResult.AddMember("CertificateMetadata", CertificateMetadata) + + _CertificateSearchResultList_member = _CertificateSearchResultList.AddMember("member", CertificateSearchResult) + + _CertificateStatuses_member = _CertificateStatuses.AddMember("member", CertificateStatus) + + CertificateSummary_CertificateArn = CertificateSummary.AddMember("CertificateArn", _Arn) + + CertificateSummary_DomainName = CertificateSummary.AddMember("DomainName", _DomainNameString) + + CertificateSummary_SubjectAlternativeNameSummaries = CertificateSummary.AddMember("SubjectAlternativeNameSummaries", _DomainList) + + CertificateSummary_HasAdditionalSubjectAlternativeNames = CertificateSummary.AddMember("HasAdditionalSubjectAlternativeNames", _NullableBoolean) + + CertificateSummary_Status = CertificateSummary.AddMember("Status", CertificateStatus) + + CertificateSummary_Type = CertificateSummary.AddMember("Type", CertificateType) + + CertificateSummary_KeyAlgorithm = CertificateSummary.AddMember("KeyAlgorithm", KeyAlgorithm) + + CertificateSummary_KeyUsages = CertificateSummary.AddMember("KeyUsages", _KeyUsageNames) + + CertificateSummary_ExtendedKeyUsages = CertificateSummary.AddMember("ExtendedKeyUsages", _ExtendedKeyUsageNames) + + CertificateSummary_ExportOption = CertificateSummary.AddMember("ExportOption", CertificateExport) + + CertificateSummary_InUse = CertificateSummary.AddMember("InUse", _NullableBoolean) + + CertificateSummary_Exported = CertificateSummary.AddMember("Exported", _NullableBoolean) + + CertificateSummary_RenewalEligibility = CertificateSummary.AddMember("RenewalEligibility", RenewalEligibility) + + CertificateSummary_NotBefore = CertificateSummary.AddMember("NotBefore", _TStamp) + + CertificateSummary_NotAfter = CertificateSummary.AddMember("NotAfter", _TStamp) + + CertificateSummary_CreatedAt = CertificateSummary.AddMember("CreatedAt", _TStamp) + + CertificateSummary_IssuedAt = CertificateSummary.AddMember("IssuedAt", _TStamp) + + CertificateSummary_ImportedAt = CertificateSummary.AddMember("ImportedAt", _TStamp) + + CertificateSummary_RevokedAt = CertificateSummary.AddMember("RevokedAt", _TStamp) + + CertificateSummary_ManagedBy = CertificateSummary.AddMember("ManagedBy", CertificateManagedBy) + + CertificateSummary_CertificateKeyPairOrigin = CertificateSummary.AddMember("CertificateKeyPairOrigin", CertificateKeyPairOrigin) + + _CertificateSummaryList_member = _CertificateSummaryList.AddMember("member", CertificateSummary) + + ConflictException_message = ConflictException.AddMember("message", _String) + + DnsPrevalidationOptions_DomainScope = DnsPrevalidationOptions.AddMember("DomainScope", DomainScope) + + DnsPrevalidationOptions_HostedZoneId = DnsPrevalidationOptions.AddMember("HostedZoneId", _HostedZoneId) + + DnsValidationChallenge_ResourceRecord = DnsValidationChallenge.AddMember("ResourceRecord", ResourceRecord) + + DomainValidationOption_DomainName = DomainValidationOption.AddMember("DomainName", _DomainNameString) + + DomainValidationOption_ValidationDomain = DomainValidationOption.AddMember("ValidationDomain", _DomainNameString) + + _DomainValidationOptionList_member = _DomainValidationOptionList.AddMember("member", DomainValidationOption) + + EmailValidationChallenge_ValidationEmails = EmailValidationChallenge.AddMember("ValidationEmails", _ValidationEmailList) + + EmailValidationChallenge_ValidationDomain = EmailValidationChallenge.AddMember("ValidationDomain", _DomainNameString) + + ValidationChallenge_EmailValidationChallenge = ValidationChallenge.AddMember("EmailValidationChallenge", EmailValidationChallenge) + + ValidationChallenge_DnsValidationChallenge = ValidationChallenge.AddMember("DnsValidationChallenge", DnsValidationChallenge) + + ValidationConfiguration_ValidationMethod = ValidationConfiguration.AddMember("ValidationMethod", ValidationMethod) + + ValidationConfiguration_ValidationChallenge = ValidationConfiguration.AddMember("ValidationChallenge", ValidationChallenge) + + ValidationConfiguration_ValidationStatus = ValidationConfiguration.AddMember("ValidationStatus", DomainStatus) + + DomainValidationSummary_DomainName = DomainValidationSummary.AddMember("DomainName", _DomainNameString) + + DomainValidationSummary_ActiveValidationConfiguration = DomainValidationSummary.AddMember("ActiveValidationConfiguration", ValidationConfiguration) + + DomainValidationSummary_RequestedValidationConfiguration = DomainValidationSummary.AddMember("RequestedValidationConfiguration", ValidationConfiguration) + + _DomainValidationSummaryList_member = _DomainValidationSummaryList.AddMember("member", DomainValidationSummary) + + TimeType_MINUTES = TimeType.AddMember("MINUTES", smithyprelude.Unit) + + TimeType_HOURS = TimeType.AddMember("HOURS", smithyprelude.Unit) + + TimeType_DAYS = TimeType.AddMember("DAYS", smithyprelude.Unit) + + Expiration_Value = Expiration.AddMember("Value", smithyprelude.Long) + + Expiration_Type = Expiration.AddMember("Type", TimeType) + + ExpiryEventsConfiguration_DaysBeforeExpiry = ExpiryEventsConfiguration.AddMember("DaysBeforeExpiry", _PositiveInteger) + + _ExtendedKeyUsageFilterList_member = _ExtendedKeyUsageFilterList.AddMember("member", ExtendedKeyUsageName) + + _KeyUsageFilterList_member = _KeyUsageFilterList.AddMember("member", KeyUsageName) + + _KeyAlgorithmList_member = _KeyAlgorithmList.AddMember("member", KeyAlgorithm) + + Filters_extendedKeyUsage = Filters.AddMember("extendedKeyUsage", _ExtendedKeyUsageFilterList) + + Filters_keyUsage = Filters.AddMember("keyUsage", _KeyUsageFilterList) + + Filters_keyTypes = Filters.AddMember("keyTypes", _KeyAlgorithmList) + + Filters_exportOption = Filters.AddMember("exportOption", CertificateExport) + + Filters_managedBy = Filters.AddMember("managedBy", CertificateManagedBy) + + InternalServerException_message = InternalServerException.AddMember("message", _String) + + InvalidArgsException_message = InvalidArgsException.AddMember("message", _String) + + InvalidArnException_message = InvalidArnException.AddMember("message", _String) + + InvalidDomainValidationOptionsException_message = InvalidDomainValidationOptionsException.AddMember("message", _String) + + InvalidParameterException_message = InvalidParameterException.AddMember("message", _String) + + InvalidStateException_message = InvalidStateException.AddMember("message", _String) + + InvalidTagException_message = InvalidTagException.AddMember("message", _String) + + LimitExceededException_message = LimitExceededException.AddMember("message", _String) + + PrevalidationOptions_DnsPrevalidation = PrevalidationOptions.AddMember("DnsPrevalidation", DnsPrevalidationOptions) + + RequestInProgressException_message = RequestInProgressException.AddMember("message", _String) + + ResourceInUseException_message = ResourceInUseException.AddMember("message", _String) + + ResourceNotFoundException_message = ResourceNotFoundException.AddMember("message", _String) + + SearchCertificatesSortBy_CREATED_AT = SearchCertificatesSortBy.AddMember("CREATED_AT", smithyprelude.Unit) + + SearchCertificatesSortBy_NOT_AFTER = SearchCertificatesSortBy.AddMember("NOT_AFTER", smithyprelude.Unit) + + SearchCertificatesSortBy_STATUS = SearchCertificatesSortBy.AddMember("STATUS", smithyprelude.Unit) + + SearchCertificatesSortBy_RENEWAL_STATUS = SearchCertificatesSortBy.AddMember("RENEWAL_STATUS", smithyprelude.Unit) + + SearchCertificatesSortBy_EXPORTED = SearchCertificatesSortBy.AddMember("EXPORTED", smithyprelude.Unit) + + SearchCertificatesSortBy_IN_USE = SearchCertificatesSortBy.AddMember("IN_USE", smithyprelude.Unit) + + SearchCertificatesSortBy_NOT_BEFORE = SearchCertificatesSortBy.AddMember("NOT_BEFORE", smithyprelude.Unit) + + SearchCertificatesSortBy_KEY_ALGORITHM = SearchCertificatesSortBy.AddMember("KEY_ALGORITHM", smithyprelude.Unit) + + SearchCertificatesSortBy_TYPE = SearchCertificatesSortBy.AddMember("TYPE", smithyprelude.Unit) + + SearchCertificatesSortBy_CERTIFICATE_ARN = SearchCertificatesSortBy.AddMember("CERTIFICATE_ARN", smithyprelude.Unit) + + SearchCertificatesSortBy_COMMON_NAME = SearchCertificatesSortBy.AddMember("COMMON_NAME", smithyprelude.Unit) + + SearchCertificatesSortBy_REVOKED_AT = SearchCertificatesSortBy.AddMember("REVOKED_AT", smithyprelude.Unit) + + SearchCertificatesSortBy_RENEWAL_ELIGIBILITY = SearchCertificatesSortBy.AddMember("RENEWAL_ELIGIBILITY", smithyprelude.Unit) + + SearchCertificatesSortBy_ISSUED_AT = SearchCertificatesSortBy.AddMember("ISSUED_AT", smithyprelude.Unit) + + SearchCertificatesSortBy_MANAGED_BY = SearchCertificatesSortBy.AddMember("MANAGED_BY", smithyprelude.Unit) + + SearchCertificatesSortBy_EXPORT_OPTION = SearchCertificatesSortBy.AddMember("EXPORT_OPTION", smithyprelude.Unit) + + SearchCertificatesSortBy_VALIDATION_METHOD = SearchCertificatesSortBy.AddMember("VALIDATION_METHOD", smithyprelude.Unit) + + SearchCertificatesSortBy_IMPORTED_AT = SearchCertificatesSortBy.AddMember("IMPORTED_AT", smithyprelude.Unit) + + SearchCertificatesSortBy_ACME_ENDPOINT_ARN = SearchCertificatesSortBy.AddMember("ACME_ENDPOINT_ARN", smithyprelude.Unit) + + SearchCertificatesSortBy_ACME_ACCOUNT_ID = SearchCertificatesSortBy.AddMember("ACME_ACCOUNT_ID", smithyprelude.Unit) + + SearchCertificatesSortBy_CERTIFICATE_KEY_PAIR_ORIGIN = SearchCertificatesSortBy.AddMember("CERTIFICATE_KEY_PAIR_ORIGIN", smithyprelude.Unit) + + SearchCertificatesSortOrder_ASCENDING = SearchCertificatesSortOrder.AddMember("ASCENDING", smithyprelude.Unit) + + SearchCertificatesSortOrder_DESCENDING = SearchCertificatesSortOrder.AddMember("DESCENDING", smithyprelude.Unit) + + ServiceQuotaExceededException_message = ServiceQuotaExceededException.AddMember("message", _String) + + SortBy_CREATED_AT = SortBy.AddMember("CREATED_AT", smithyprelude.Unit) + + SortOrder_ASCENDING = SortOrder.AddMember("ASCENDING", smithyprelude.Unit) + + SortOrder_DESCENDING = SortOrder.AddMember("DESCENDING", smithyprelude.Unit) + + _TagKeyList_member = _TagKeyList.AddMember("member", _TagKey) + + TagPolicyException_message = TagPolicyException.AddMember("message", _String) + + ThrottlingReason_reason = ThrottlingReason.AddMember("reason", _CoralAvailabilityThrottlingReason) + + ThrottlingReason_resource = ThrottlingReason.AddMember("resource", _CoralAvailabilityThrottledResource) + + _ThrottlingReasonList_member = _ThrottlingReasonList.AddMember("member", ThrottlingReason) + + ThrottlingException_message = ThrottlingException.AddMember("message", _AvailabilityErrorMessage) + + ThrottlingException_throttlingReasons = ThrottlingException.AddMember("throttlingReasons", _ThrottlingReasonList) + + TooManyTagsException_message = TooManyTagsException.AddMember("message", _String) + + ValidationException_message = ValidationException.AddMember("message", _ValidationExceptionMessage) + + AddTagsToCertificateRequest_CertificateArn = AddTagsToCertificateRequest.AddMember("CertificateArn", _Arn) + + AddTagsToCertificateRequest_Tags = AddTagsToCertificateRequest.AddMember("Tags", _TagList) + + CreateAcmeDomainValidationRequest_IdempotencyToken = CreateAcmeDomainValidationRequest.AddMember("IdempotencyToken", smithyprelude.String) + + CreateAcmeDomainValidationRequest_AcmeEndpointArn = CreateAcmeDomainValidationRequest.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + CreateAcmeDomainValidationRequest_DomainName = CreateAcmeDomainValidationRequest.AddMember("DomainName", _DomainName) + + CreateAcmeDomainValidationRequest_PrevalidationOptions = CreateAcmeDomainValidationRequest.AddMember("PrevalidationOptions", PrevalidationOptions) + + CreateAcmeDomainValidationRequest_Tags = CreateAcmeDomainValidationRequest.AddMember("Tags", _TagList) + + CreateAcmeDomainValidationResponse_AcmeDomainValidationArn = CreateAcmeDomainValidationResponse.AddMember("AcmeDomainValidationArn", _AcmeDomainValidationArn) + + CreateAcmeEndpointRequest_IdempotencyToken = CreateAcmeEndpointRequest.AddMember("IdempotencyToken", smithyprelude.String) + + CreateAcmeEndpointRequest_AuthorizationBehavior = CreateAcmeEndpointRequest.AddMember("AuthorizationBehavior", AcmeAuthorizationBehavior) + + CreateAcmeEndpointRequest_Contact = CreateAcmeEndpointRequest.AddMember("Contact", AcmeContact) + + CreateAcmeEndpointRequest_CertificateAuthority = CreateAcmeEndpointRequest.AddMember("CertificateAuthority", CertificateAuthority) + + CreateAcmeEndpointRequest_Tags = CreateAcmeEndpointRequest.AddMember("Tags", _TagList) + + CreateAcmeEndpointRequest_CertificateTags = CreateAcmeEndpointRequest.AddMember("CertificateTags", _TagList) + + CreateAcmeEndpointResponse_AcmeEndpointArn = CreateAcmeEndpointResponse.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + CreateAcmeExternalAccountBindingRequest_IdempotencyToken = CreateAcmeExternalAccountBindingRequest.AddMember("IdempotencyToken", smithyprelude.String) + + CreateAcmeExternalAccountBindingRequest_AcmeEndpointArn = CreateAcmeExternalAccountBindingRequest.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + CreateAcmeExternalAccountBindingRequest_RoleArn = CreateAcmeExternalAccountBindingRequest.AddMember("RoleArn", _RoleArn) + + CreateAcmeExternalAccountBindingRequest_Expiration = CreateAcmeExternalAccountBindingRequest.AddMember("Expiration", Expiration) + + CreateAcmeExternalAccountBindingRequest_Tags = CreateAcmeExternalAccountBindingRequest.AddMember("Tags", _TagList) + + CreateAcmeExternalAccountBindingResponse_ExternalAccountBinding = CreateAcmeExternalAccountBindingResponse.AddMember("ExternalAccountBinding", AcmeExternalAccountBinding) + + DeleteAcmeDomainValidationRequest_AcmeDomainValidationArn = DeleteAcmeDomainValidationRequest.AddMember("AcmeDomainValidationArn", _AcmeDomainValidationArn) + + DeleteAcmeEndpointRequest_AcmeEndpointArn = DeleteAcmeEndpointRequest.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + DeleteAcmeExternalAccountBindingRequest_AcmeExternalAccountBindingArn = DeleteAcmeExternalAccountBindingRequest.AddMember("AcmeExternalAccountBindingArn", _AcmeExternalAccountBindingArn) + + DeleteCertificateRequest_CertificateArn = DeleteCertificateRequest.AddMember("CertificateArn", _Arn) + + DescribeAcmeAccountRequest_AcmeEndpointArn = DescribeAcmeAccountRequest.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + DescribeAcmeAccountRequest_AccountUrl = DescribeAcmeAccountRequest.AddMember("AccountUrl", smithyprelude.String) + + DescribeAcmeAccountResponse_AcmeAccount = DescribeAcmeAccountResponse.AddMember("AcmeAccount", AcmeAccount) + + DescribeAcmeDomainValidationRequest_AcmeDomainValidationArn = DescribeAcmeDomainValidationRequest.AddMember("AcmeDomainValidationArn", _AcmeDomainValidationArn) + + DescribeAcmeDomainValidationResponse_AcmeDomainValidation = DescribeAcmeDomainValidationResponse.AddMember("AcmeDomainValidation", AcmeDomainValidation) + + DescribeAcmeEndpointRequest_AcmeEndpointArn = DescribeAcmeEndpointRequest.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + DescribeAcmeEndpointResponse_AcmeEndpoint = DescribeAcmeEndpointResponse.AddMember("AcmeEndpoint", AcmeEndpoint) + + DescribeAcmeExternalAccountBindingRequest_AcmeExternalAccountBindingArn = DescribeAcmeExternalAccountBindingRequest.AddMember("AcmeExternalAccountBindingArn", _AcmeExternalAccountBindingArn) + + DescribeAcmeExternalAccountBindingResponse_ExternalAccountBinding = DescribeAcmeExternalAccountBindingResponse.AddMember("ExternalAccountBinding", AcmeExternalAccountBinding) + + DescribeCertificateRequest_CertificateArn = DescribeCertificateRequest.AddMember("CertificateArn", _Arn) + + DescribeCertificateResponse_Certificate = DescribeCertificateResponse.AddMember("Certificate", CertificateDetail) + + ExportCertificateRequest_CertificateArn = ExportCertificateRequest.AddMember("CertificateArn", _Arn) + + ExportCertificateRequest_Passphrase = ExportCertificateRequest.AddMember("Passphrase", _PassphraseBlob) + + ExportCertificateResponse_Certificate = ExportCertificateResponse.AddMember("Certificate", _CertificateBody) + + ExportCertificateResponse_CertificateChain = ExportCertificateResponse.AddMember("CertificateChain", _CertificateChain) + + ExportCertificateResponse_PrivateKey = ExportCertificateResponse.AddMember("PrivateKey", _PrivateKey) + + GetAccountConfigurationResponse_ExpiryEvents = GetAccountConfigurationResponse.AddMember("ExpiryEvents", ExpiryEventsConfiguration) + + GetAcmeExternalAccountBindingCredentialsRequest_AcmeExternalAccountBindingArn = GetAcmeExternalAccountBindingCredentialsRequest.AddMember("AcmeExternalAccountBindingArn", _AcmeExternalAccountBindingArn) + + GetAcmeExternalAccountBindingCredentialsResponse_KeyId = GetAcmeExternalAccountBindingCredentialsResponse.AddMember("KeyId", smithyprelude.String) + + GetAcmeExternalAccountBindingCredentialsResponse_MacKey = GetAcmeExternalAccountBindingCredentialsResponse.AddMember("MacKey", _MacKey) + + GetCertificateRequest_CertificateArn = GetCertificateRequest.AddMember("CertificateArn", _Arn) + + GetCertificateResponse_Certificate = GetCertificateResponse.AddMember("Certificate", _CertificateBody) + + GetCertificateResponse_CertificateChain = GetCertificateResponse.AddMember("CertificateChain", _CertificateChain) + + ImportCertificateRequest_CertificateArn = ImportCertificateRequest.AddMember("CertificateArn", _Arn) + + ImportCertificateRequest_Certificate = ImportCertificateRequest.AddMember("Certificate", _CertificateBodyBlob) + + ImportCertificateRequest_PrivateKey = ImportCertificateRequest.AddMember("PrivateKey", _PrivateKeyBlob) + + ImportCertificateRequest_CertificateChain = ImportCertificateRequest.AddMember("CertificateChain", _CertificateChainBlob) + + ImportCertificateRequest_Tags = ImportCertificateRequest.AddMember("Tags", _TagList) + + ImportCertificateResponse_CertificateArn = ImportCertificateResponse.AddMember("CertificateArn", _Arn) + + ListAcmeAccountsRequest_NextToken = ListAcmeAccountsRequest.AddMember("NextToken", smithyprelude.String) + + ListAcmeAccountsRequest_MaxResults = ListAcmeAccountsRequest.AddMember("MaxResults", smithyprelude.Integer) + + ListAcmeAccountsRequest_AcmeEndpointArn = ListAcmeAccountsRequest.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + ListAcmeAccountsResponse_AcmeAccounts = ListAcmeAccountsResponse.AddMember("AcmeAccounts", _AcmeAccountList) + + ListAcmeAccountsResponse_NextToken = ListAcmeAccountsResponse.AddMember("NextToken", smithyprelude.String) + + ListAcmeDomainValidationsRequest_NextToken = ListAcmeDomainValidationsRequest.AddMember("NextToken", smithyprelude.String) + + ListAcmeDomainValidationsRequest_MaxResults = ListAcmeDomainValidationsRequest.AddMember("MaxResults", smithyprelude.Integer) + + ListAcmeDomainValidationsRequest_AcmeEndpointArn = ListAcmeDomainValidationsRequest.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + ListAcmeDomainValidationsResponse_AcmeDomainValidations = ListAcmeDomainValidationsResponse.AddMember("AcmeDomainValidations", _AcmeDomainValidationList) + + ListAcmeDomainValidationsResponse_NextToken = ListAcmeDomainValidationsResponse.AddMember("NextToken", smithyprelude.String) + + ListAcmeEndpointsRequest_NextToken = ListAcmeEndpointsRequest.AddMember("NextToken", smithyprelude.String) + + ListAcmeEndpointsRequest_MaxResults = ListAcmeEndpointsRequest.AddMember("MaxResults", smithyprelude.Integer) + + ListAcmeEndpointsResponse_AcmeEndpoints = ListAcmeEndpointsResponse.AddMember("AcmeEndpoints", _AcmeEndpointList) + + ListAcmeEndpointsResponse_NextToken = ListAcmeEndpointsResponse.AddMember("NextToken", smithyprelude.String) + + ListAcmeExternalAccountBindingsRequest_NextToken = ListAcmeExternalAccountBindingsRequest.AddMember("NextToken", smithyprelude.String) + + ListAcmeExternalAccountBindingsRequest_MaxResults = ListAcmeExternalAccountBindingsRequest.AddMember("MaxResults", smithyprelude.Integer) + + ListAcmeExternalAccountBindingsRequest_AcmeEndpointArn = ListAcmeExternalAccountBindingsRequest.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + ListAcmeExternalAccountBindingsResponse_ExternalAccountBindings = ListAcmeExternalAccountBindingsResponse.AddMember("ExternalAccountBindings", _AcmeExternalAccountBindingList) + + ListAcmeExternalAccountBindingsResponse_NextToken = ListAcmeExternalAccountBindingsResponse.AddMember("NextToken", smithyprelude.String) + + ListCertificateDomainValidationsRequest_CertificateArn = ListCertificateDomainValidationsRequest.AddMember("CertificateArn", _CertificateArn) + + ListCertificateDomainValidationsRequest_NextToken = ListCertificateDomainValidationsRequest.AddMember("NextToken", _NextToken) + + ListCertificateDomainValidationsRequest_MaxItems = ListCertificateDomainValidationsRequest.AddMember("MaxItems", _MaxItems) + + ListCertificateDomainValidationsResponse_DomainValidationSummaryList = ListCertificateDomainValidationsResponse.AddMember("DomainValidationSummaryList", _DomainValidationSummaryList) + + ListCertificateDomainValidationsResponse_NextToken = ListCertificateDomainValidationsResponse.AddMember("NextToken", _NextToken) + + ListCertificatesRequest_CertificateStatuses = ListCertificatesRequest.AddMember("CertificateStatuses", _CertificateStatuses) + + ListCertificatesRequest_CertificateKeyPairOrigins = ListCertificatesRequest.AddMember("CertificateKeyPairOrigins", _CertificateKeyPairOrigins) + + ListCertificatesRequest_Includes = ListCertificatesRequest.AddMember("Includes", Filters) + + ListCertificatesRequest_NextToken = ListCertificatesRequest.AddMember("NextToken", _NextToken) + + ListCertificatesRequest_MaxItems = ListCertificatesRequest.AddMember("MaxItems", _MaxItems) + + ListCertificatesRequest_SortBy = ListCertificatesRequest.AddMember("SortBy", SortBy) + + ListCertificatesRequest_SortOrder = ListCertificatesRequest.AddMember("SortOrder", SortOrder) + + ListCertificatesResponse_NextToken = ListCertificatesResponse.AddMember("NextToken", _NextToken) + + ListCertificatesResponse_CertificateSummaryList = ListCertificatesResponse.AddMember("CertificateSummaryList", _CertificateSummaryList) + + ListTagsForCertificateRequest_CertificateArn = ListTagsForCertificateRequest.AddMember("CertificateArn", _Arn) + + ListTagsForCertificateResponse_Tags = ListTagsForCertificateResponse.AddMember("Tags", _TagList) + + ListTagsForResourceRequest_ResourceArn = ListTagsForResourceRequest.AddMember("ResourceArn", _Arn) + + ListTagsForResourceResponse_Tags = ListTagsForResourceResponse.AddMember("Tags", _TagList) + + PutAccountConfigurationRequest_ExpiryEvents = PutAccountConfigurationRequest.AddMember("ExpiryEvents", ExpiryEventsConfiguration) + + PutAccountConfigurationRequest_IdempotencyToken = PutAccountConfigurationRequest.AddMember("IdempotencyToken", _IdempotencyToken) + + RemoveTagsFromCertificateRequest_CertificateArn = RemoveTagsFromCertificateRequest.AddMember("CertificateArn", _Arn) + + RemoveTagsFromCertificateRequest_Tags = RemoveTagsFromCertificateRequest.AddMember("Tags", _TagList) + + RenewCertificateRequest_CertificateArn = RenewCertificateRequest.AddMember("CertificateArn", _Arn) + + RequestCertificateRequest_DomainName = RequestCertificateRequest.AddMember("DomainName", _DomainNameString) + + RequestCertificateRequest_ValidationMethod = RequestCertificateRequest.AddMember("ValidationMethod", ValidationMethod) + + RequestCertificateRequest_SubjectAlternativeNames = RequestCertificateRequest.AddMember("SubjectAlternativeNames", _DomainList) + + RequestCertificateRequest_IdempotencyToken = RequestCertificateRequest.AddMember("IdempotencyToken", _IdempotencyToken) + + RequestCertificateRequest_DomainValidationOptions = RequestCertificateRequest.AddMember("DomainValidationOptions", _DomainValidationOptionList) + + RequestCertificateRequest_Options = RequestCertificateRequest.AddMember("Options", CertificateOptions) + + RequestCertificateRequest_CertificateAuthorityArn = RequestCertificateRequest.AddMember("CertificateAuthorityArn", _PcaArn) + + RequestCertificateRequest_Tags = RequestCertificateRequest.AddMember("Tags", _TagList) + + RequestCertificateRequest_KeyAlgorithm = RequestCertificateRequest.AddMember("KeyAlgorithm", KeyAlgorithm) + + RequestCertificateRequest_ManagedBy = RequestCertificateRequest.AddMember("ManagedBy", CertificateManagedBy) + + RequestCertificateResponse_CertificateArn = RequestCertificateResponse.AddMember("CertificateArn", _Arn) + + ResendValidationEmailRequest_CertificateArn = ResendValidationEmailRequest.AddMember("CertificateArn", _Arn) + + ResendValidationEmailRequest_Domain = ResendValidationEmailRequest.AddMember("Domain", _DomainNameString) + + ResendValidationEmailRequest_ValidationDomain = ResendValidationEmailRequest.AddMember("ValidationDomain", _DomainNameString) + + RevokeAcmeAccountRequest_AcmeEndpointArn = RevokeAcmeAccountRequest.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + RevokeAcmeAccountRequest_AccountUrl = RevokeAcmeAccountRequest.AddMember("AccountUrl", smithyprelude.String) + + RevokeAcmeExternalAccountBindingRequest_AcmeExternalAccountBindingArn = RevokeAcmeExternalAccountBindingRequest.AddMember("AcmeExternalAccountBindingArn", _AcmeExternalAccountBindingArn) + + RevokeCertificateRequest_CertificateArn = RevokeCertificateRequest.AddMember("CertificateArn", _Arn) + + RevokeCertificateRequest_RevocationReason = RevokeCertificateRequest.AddMember("RevocationReason", RevocationReason) + + RevokeCertificateResponse_CertificateArn = RevokeCertificateResponse.AddMember("CertificateArn", _Arn) + + SearchCertificatesRequest_FilterStatement = SearchCertificatesRequest.AddMember("FilterStatement", CertificateFilterStatement) + + SearchCertificatesRequest_MaxResults = SearchCertificatesRequest.AddMember("MaxResults", _SearchMaxResults) + + SearchCertificatesRequest_NextToken = SearchCertificatesRequest.AddMember("NextToken", _NextToken) + + SearchCertificatesRequest_SortBy = SearchCertificatesRequest.AddMember("SortBy", SearchCertificatesSortBy) + + SearchCertificatesRequest_SortOrder = SearchCertificatesRequest.AddMember("SortOrder", SearchCertificatesSortOrder) + + SearchCertificatesResponse_Results = SearchCertificatesResponse.AddMember("Results", _CertificateSearchResultList) + + SearchCertificatesResponse_NextToken = SearchCertificatesResponse.AddMember("NextToken", _NextToken) + + TagResourceRequest_ResourceArn = TagResourceRequest.AddMember("ResourceArn", _Arn) + + TagResourceRequest_Tags = TagResourceRequest.AddMember("Tags", _TagList) + + UntagResourceRequest_ResourceArn = UntagResourceRequest.AddMember("ResourceArn", _Arn) + + UntagResourceRequest_TagKeys = UntagResourceRequest.AddMember("TagKeys", _TagKeyList) + + UpdateAcmeDomainValidationRequest_AcmeDomainValidationArn = UpdateAcmeDomainValidationRequest.AddMember("AcmeDomainValidationArn", _AcmeDomainValidationArn) + + UpdateAcmeDomainValidationRequest_PrevalidationOptions = UpdateAcmeDomainValidationRequest.AddMember("PrevalidationOptions", PrevalidationOptions) + + UpdateAcmeEndpointRequest_AcmeEndpointArn = UpdateAcmeEndpointRequest.AddMember("AcmeEndpointArn", _AcmeEndpointArn) + + UpdateAcmeEndpointRequest_AuthorizationBehavior = UpdateAcmeEndpointRequest.AddMember("AuthorizationBehavior", AcmeAuthorizationBehavior) + + UpdateAcmeEndpointRequest_Contact = UpdateAcmeEndpointRequest.AddMember("Contact", AcmeContact) + + UpdateAcmeEndpointRequest_CertificateAuthority = UpdateAcmeEndpointRequest.AddMember("CertificateAuthority", CertificateAuthority) + + UpdateCertificateOptionsRequest_CertificateArn = UpdateCertificateOptionsRequest.AddMember("CertificateArn", _Arn) + + UpdateCertificateOptionsRequest_Options = UpdateCertificateOptionsRequest.AddMember("Options", CertificateOptions) + +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/serializers.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/serializers.go deleted file mode 100644 index c966988e5..000000000 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/serializers.go +++ /dev/null @@ -1,1861 +0,0 @@ -// Code generated by smithy-go-codegen DO NOT EDIT. - -package acm - -import ( - "bytes" - "context" - "fmt" - "github.com/aws/aws-sdk-go-v2/service/acm/types" - smithy "github.com/aws/smithy-go" - "github.com/aws/smithy-go/encoding/httpbinding" - smithyjson "github.com/aws/smithy-go/encoding/json" - "github.com/aws/smithy-go/middleware" - smithytime "github.com/aws/smithy-go/time" - "github.com/aws/smithy-go/tracing" - smithyhttp "github.com/aws/smithy-go/transport/http" - "path" - "strings" -) - -type awsAwsjson11_serializeOpAddTagsToCertificate struct { -} - -func (*awsAwsjson11_serializeOpAddTagsToCertificate) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpAddTagsToCertificate) 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.(*AddTagsToCertificateInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.AddTagsToCertificate") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentAddTagsToCertificateInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpDeleteCertificate struct { -} - -func (*awsAwsjson11_serializeOpDeleteCertificate) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpDeleteCertificate) 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.(*DeleteCertificateInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.DeleteCertificate") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentDeleteCertificateInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpDescribeCertificate struct { -} - -func (*awsAwsjson11_serializeOpDescribeCertificate) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpDescribeCertificate) 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.(*DescribeCertificateInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.DescribeCertificate") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentDescribeCertificateInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpExportCertificate struct { -} - -func (*awsAwsjson11_serializeOpExportCertificate) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpExportCertificate) 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.(*ExportCertificateInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.ExportCertificate") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentExportCertificateInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpGetAccountConfiguration struct { -} - -func (*awsAwsjson11_serializeOpGetAccountConfiguration) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpGetAccountConfiguration) 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.(*GetAccountConfigurationInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.GetAccountConfiguration") - - if request, err = request.SetStream(strings.NewReader(`{}`)); 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 awsAwsjson11_serializeOpGetCertificate struct { -} - -func (*awsAwsjson11_serializeOpGetCertificate) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpGetCertificate) 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.(*GetCertificateInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.GetCertificate") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentGetCertificateInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpImportCertificate struct { -} - -func (*awsAwsjson11_serializeOpImportCertificate) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpImportCertificate) 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.(*ImportCertificateInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.ImportCertificate") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentImportCertificateInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpListCertificates struct { -} - -func (*awsAwsjson11_serializeOpListCertificates) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpListCertificates) 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.(*ListCertificatesInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.ListCertificates") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentListCertificatesInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpListTagsForCertificate struct { -} - -func (*awsAwsjson11_serializeOpListTagsForCertificate) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpListTagsForCertificate) 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.(*ListTagsForCertificateInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.ListTagsForCertificate") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentListTagsForCertificateInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpPutAccountConfiguration struct { -} - -func (*awsAwsjson11_serializeOpPutAccountConfiguration) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpPutAccountConfiguration) 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.(*PutAccountConfigurationInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.PutAccountConfiguration") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentPutAccountConfigurationInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpRemoveTagsFromCertificate struct { -} - -func (*awsAwsjson11_serializeOpRemoveTagsFromCertificate) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpRemoveTagsFromCertificate) 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.(*RemoveTagsFromCertificateInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.RemoveTagsFromCertificate") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentRemoveTagsFromCertificateInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpRenewCertificate struct { -} - -func (*awsAwsjson11_serializeOpRenewCertificate) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpRenewCertificate) 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.(*RenewCertificateInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.RenewCertificate") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentRenewCertificateInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpRequestCertificate struct { -} - -func (*awsAwsjson11_serializeOpRequestCertificate) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpRequestCertificate) 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.(*RequestCertificateInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.RequestCertificate") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentRequestCertificateInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpResendValidationEmail struct { -} - -func (*awsAwsjson11_serializeOpResendValidationEmail) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpResendValidationEmail) 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.(*ResendValidationEmailInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.ResendValidationEmail") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentResendValidationEmailInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpRevokeCertificate struct { -} - -func (*awsAwsjson11_serializeOpRevokeCertificate) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpRevokeCertificate) 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.(*RevokeCertificateInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.RevokeCertificate") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentRevokeCertificateInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpSearchCertificates struct { -} - -func (*awsAwsjson11_serializeOpSearchCertificates) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpSearchCertificates) 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.(*SearchCertificatesInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.SearchCertificates") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentSearchCertificatesInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} - -type awsAwsjson11_serializeOpUpdateCertificateOptions struct { -} - -func (*awsAwsjson11_serializeOpUpdateCertificateOptions) ID() string { - return "OperationSerializer" -} - -func (m *awsAwsjson11_serializeOpUpdateCertificateOptions) 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.(*UpdateCertificateOptionsInput) - _ = input - if !ok { - return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} - } - - operationPath := "/" - if len(request.Request.URL.Path) == 0 { - request.Request.URL.Path = operationPath - } else { - request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) - if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { - request.Request.URL.Path += "/" - } - } - request.Request.Method = "POST" - httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) - if err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") - httpBindingEncoder.SetHeader("X-Amz-Target").String("CertificateManager.UpdateCertificateOptions") - - jsonEncoder := smithyjson.NewEncoder() - if err := awsAwsjson11_serializeOpDocumentUpdateCertificateOptionsInput(input, jsonEncoder.Value); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - - if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { - return out, metadata, &smithy.SerializationError{Err: err} - } - in.Request = request - - endTimer() - span.End() - return next.HandleSerialize(ctx, in) -} -func awsAwsjson11_serializeDocumentAcmCertificateMetadataFilter(v types.AcmCertificateMetadataFilter, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - switch uv := v.(type) { - case *types.AcmCertificateMetadataFilterMemberExported: - av := object.Key("Exported") - av.Boolean(uv.Value) - - case *types.AcmCertificateMetadataFilterMemberExportOption: - av := object.Key("ExportOption") - av.String(string(uv.Value)) - - case *types.AcmCertificateMetadataFilterMemberInUse: - av := object.Key("InUse") - av.Boolean(uv.Value) - - case *types.AcmCertificateMetadataFilterMemberManagedBy: - av := object.Key("ManagedBy") - av.String(string(uv.Value)) - - case *types.AcmCertificateMetadataFilterMemberRenewalStatus: - av := object.Key("RenewalStatus") - av.String(string(uv.Value)) - - case *types.AcmCertificateMetadataFilterMemberStatus: - av := object.Key("Status") - av.String(string(uv.Value)) - - case *types.AcmCertificateMetadataFilterMemberType: - av := object.Key("Type") - av.String(string(uv.Value)) - - case *types.AcmCertificateMetadataFilterMemberValidationMethod: - av := object.Key("ValidationMethod") - av.String(string(uv.Value)) - - default: - return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) - - } - return nil -} - -func awsAwsjson11_serializeDocumentCertificateFilter(v types.CertificateFilter, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - switch uv := v.(type) { - case *types.CertificateFilterMemberAcmCertificateMetadataFilter: - av := object.Key("AcmCertificateMetadataFilter") - if err := awsAwsjson11_serializeDocumentAcmCertificateMetadataFilter(uv.Value, av); err != nil { - return err - } - - case *types.CertificateFilterMemberCertificateArn: - av := object.Key("CertificateArn") - av.String(uv.Value) - - case *types.CertificateFilterMemberX509AttributeFilter: - av := object.Key("X509AttributeFilter") - if err := awsAwsjson11_serializeDocumentX509AttributeFilter(uv.Value, av); err != nil { - return err - } - - default: - return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) - - } - return nil -} - -func awsAwsjson11_serializeDocumentCertificateFilterStatement(v types.CertificateFilterStatement, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - switch uv := v.(type) { - case *types.CertificateFilterStatementMemberAnd: - av := object.Key("And") - if err := awsAwsjson11_serializeDocumentCertificateFilterStatementList(uv.Value, av); err != nil { - return err - } - - case *types.CertificateFilterStatementMemberFilter: - av := object.Key("Filter") - if err := awsAwsjson11_serializeDocumentCertificateFilter(uv.Value, av); err != nil { - return err - } - - case *types.CertificateFilterStatementMemberNot: - av := object.Key("Not") - if err := awsAwsjson11_serializeDocumentCertificateFilterStatement(uv.Value, av); err != nil { - return err - } - - case *types.CertificateFilterStatementMemberOr: - av := object.Key("Or") - if err := awsAwsjson11_serializeDocumentCertificateFilterStatementList(uv.Value, av); err != nil { - return err - } - - default: - return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) - - } - return nil -} - -func awsAwsjson11_serializeDocumentCertificateFilterStatementList(v []types.CertificateFilterStatement, value smithyjson.Value) error { - array := value.Array() - defer array.Close() - - for i := range v { - av := array.Value() - if vv := v[i]; vv == nil { - continue - } - if err := awsAwsjson11_serializeDocumentCertificateFilterStatement(v[i], av); err != nil { - return err - } - } - return nil -} - -func awsAwsjson11_serializeDocumentCertificateOptions(v *types.CertificateOptions, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if len(v.CertificateTransparencyLoggingPreference) > 0 { - ok := object.Key("CertificateTransparencyLoggingPreference") - ok.String(string(v.CertificateTransparencyLoggingPreference)) - } - - if len(v.Export) > 0 { - ok := object.Key("Export") - ok.String(string(v.Export)) - } - - return nil -} - -func awsAwsjson11_serializeDocumentCertificateStatuses(v []types.CertificateStatus, value smithyjson.Value) error { - array := value.Array() - defer array.Close() - - for i := range v { - av := array.Value() - av.String(string(v[i])) - } - return nil -} - -func awsAwsjson11_serializeDocumentCommonNameFilter(v *types.CommonNameFilter, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if len(v.ComparisonOperator) > 0 { - ok := object.Key("ComparisonOperator") - ok.String(string(v.ComparisonOperator)) - } - - if v.Value != nil { - ok := object.Key("Value") - ok.String(*v.Value) - } - - return nil -} - -func awsAwsjson11_serializeDocumentDnsNameFilter(v *types.DnsNameFilter, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if len(v.ComparisonOperator) > 0 { - ok := object.Key("ComparisonOperator") - ok.String(string(v.ComparisonOperator)) - } - - if v.Value != nil { - ok := object.Key("Value") - ok.String(*v.Value) - } - - return nil -} - -func awsAwsjson11_serializeDocumentDomainList(v []string, value smithyjson.Value) error { - array := value.Array() - defer array.Close() - - for i := range v { - av := array.Value() - av.String(v[i]) - } - return nil -} - -func awsAwsjson11_serializeDocumentDomainValidationOption(v *types.DomainValidationOption, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.DomainName != nil { - ok := object.Key("DomainName") - ok.String(*v.DomainName) - } - - if v.ValidationDomain != nil { - ok := object.Key("ValidationDomain") - ok.String(*v.ValidationDomain) - } - - return nil -} - -func awsAwsjson11_serializeDocumentDomainValidationOptionList(v []types.DomainValidationOption, value smithyjson.Value) error { - array := value.Array() - defer array.Close() - - for i := range v { - av := array.Value() - if err := awsAwsjson11_serializeDocumentDomainValidationOption(&v[i], av); err != nil { - return err - } - } - return nil -} - -func awsAwsjson11_serializeDocumentExpiryEventsConfiguration(v *types.ExpiryEventsConfiguration, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.DaysBeforeExpiry != nil { - ok := object.Key("DaysBeforeExpiry") - ok.Integer(*v.DaysBeforeExpiry) - } - - return nil -} - -func awsAwsjson11_serializeDocumentExtendedKeyUsageFilterList(v []types.ExtendedKeyUsageName, value smithyjson.Value) error { - array := value.Array() - defer array.Close() - - for i := range v { - av := array.Value() - av.String(string(v[i])) - } - return nil -} - -func awsAwsjson11_serializeDocumentFilters(v *types.Filters, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if len(v.ExportOption) > 0 { - ok := object.Key("exportOption") - ok.String(string(v.ExportOption)) - } - - if v.ExtendedKeyUsage != nil { - ok := object.Key("extendedKeyUsage") - if err := awsAwsjson11_serializeDocumentExtendedKeyUsageFilterList(v.ExtendedKeyUsage, ok); err != nil { - return err - } - } - - if v.KeyTypes != nil { - ok := object.Key("keyTypes") - if err := awsAwsjson11_serializeDocumentKeyAlgorithmList(v.KeyTypes, ok); err != nil { - return err - } - } - - if v.KeyUsage != nil { - ok := object.Key("keyUsage") - if err := awsAwsjson11_serializeDocumentKeyUsageFilterList(v.KeyUsage, ok); err != nil { - return err - } - } - - if len(v.ManagedBy) > 0 { - ok := object.Key("managedBy") - ok.String(string(v.ManagedBy)) - } - - return nil -} - -func awsAwsjson11_serializeDocumentKeyAlgorithmList(v []types.KeyAlgorithm, value smithyjson.Value) error { - array := value.Array() - defer array.Close() - - for i := range v { - av := array.Value() - av.String(string(v[i])) - } - return nil -} - -func awsAwsjson11_serializeDocumentKeyUsageFilterList(v []types.KeyUsageName, value smithyjson.Value) error { - array := value.Array() - defer array.Close() - - for i := range v { - av := array.Value() - av.String(string(v[i])) - } - return nil -} - -func awsAwsjson11_serializeDocumentSubjectAlternativeNameFilter(v types.SubjectAlternativeNameFilter, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - switch uv := v.(type) { - case *types.SubjectAlternativeNameFilterMemberDnsName: - av := object.Key("DnsName") - if err := awsAwsjson11_serializeDocumentDnsNameFilter(&uv.Value, av); err != nil { - return err - } - - default: - return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) - - } - return nil -} - -func awsAwsjson11_serializeDocumentSubjectFilter(v types.SubjectFilter, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - switch uv := v.(type) { - case *types.SubjectFilterMemberCommonName: - av := object.Key("CommonName") - if err := awsAwsjson11_serializeDocumentCommonNameFilter(&uv.Value, av); err != nil { - return err - } - - default: - return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) - - } - return nil -} - -func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.Key != nil { - ok := object.Key("Key") - ok.String(*v.Key) - } - - if v.Value != nil { - ok := object.Key("Value") - ok.String(*v.Value) - } - - return nil -} - -func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error { - array := value.Array() - defer array.Close() - - for i := range v { - av := array.Value() - if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil { - return err - } - } - return nil -} - -func awsAwsjson11_serializeDocumentTimestampRange(v *types.TimestampRange, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.End != nil { - ok := object.Key("End") - ok.Double(smithytime.FormatEpochSeconds(*v.End)) - } - - if v.Start != nil { - ok := object.Key("Start") - ok.Double(smithytime.FormatEpochSeconds(*v.Start)) - } - - return nil -} - -func awsAwsjson11_serializeDocumentX509AttributeFilter(v types.X509AttributeFilter, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - switch uv := v.(type) { - case *types.X509AttributeFilterMemberExtendedKeyUsage: - av := object.Key("ExtendedKeyUsage") - av.String(string(uv.Value)) - - case *types.X509AttributeFilterMemberKeyAlgorithm: - av := object.Key("KeyAlgorithm") - av.String(string(uv.Value)) - - case *types.X509AttributeFilterMemberKeyUsage: - av := object.Key("KeyUsage") - av.String(string(uv.Value)) - - case *types.X509AttributeFilterMemberNotAfter: - av := object.Key("NotAfter") - if err := awsAwsjson11_serializeDocumentTimestampRange(&uv.Value, av); err != nil { - return err - } - - case *types.X509AttributeFilterMemberNotBefore: - av := object.Key("NotBefore") - if err := awsAwsjson11_serializeDocumentTimestampRange(&uv.Value, av); err != nil { - return err - } - - case *types.X509AttributeFilterMemberSerialNumber: - av := object.Key("SerialNumber") - av.String(uv.Value) - - case *types.X509AttributeFilterMemberSubject: - av := object.Key("Subject") - if err := awsAwsjson11_serializeDocumentSubjectFilter(uv.Value, av); err != nil { - return err - } - - case *types.X509AttributeFilterMemberSubjectAlternativeName: - av := object.Key("SubjectAlternativeName") - if err := awsAwsjson11_serializeDocumentSubjectAlternativeNameFilter(uv.Value, av); err != nil { - return err - } - - default: - return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) - - } - return nil -} - -func awsAwsjson11_serializeOpDocumentAddTagsToCertificateInput(v *AddTagsToCertificateInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.CertificateArn != nil { - ok := object.Key("CertificateArn") - ok.String(*v.CertificateArn) - } - - if v.Tags != nil { - ok := object.Key("Tags") - if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil { - return err - } - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentDeleteCertificateInput(v *DeleteCertificateInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.CertificateArn != nil { - ok := object.Key("CertificateArn") - ok.String(*v.CertificateArn) - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentDescribeCertificateInput(v *DescribeCertificateInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.CertificateArn != nil { - ok := object.Key("CertificateArn") - ok.String(*v.CertificateArn) - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentExportCertificateInput(v *ExportCertificateInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.CertificateArn != nil { - ok := object.Key("CertificateArn") - ok.String(*v.CertificateArn) - } - - if v.Passphrase != nil { - ok := object.Key("Passphrase") - ok.Base64EncodeBytes(v.Passphrase) - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentGetCertificateInput(v *GetCertificateInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.CertificateArn != nil { - ok := object.Key("CertificateArn") - ok.String(*v.CertificateArn) - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentImportCertificateInput(v *ImportCertificateInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.Certificate != nil { - ok := object.Key("Certificate") - ok.Base64EncodeBytes(v.Certificate) - } - - if v.CertificateArn != nil { - ok := object.Key("CertificateArn") - ok.String(*v.CertificateArn) - } - - if v.CertificateChain != nil { - ok := object.Key("CertificateChain") - ok.Base64EncodeBytes(v.CertificateChain) - } - - if v.PrivateKey != nil { - ok := object.Key("PrivateKey") - ok.Base64EncodeBytes(v.PrivateKey) - } - - if v.Tags != nil { - ok := object.Key("Tags") - if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil { - return err - } - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentListCertificatesInput(v *ListCertificatesInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.CertificateStatuses != nil { - ok := object.Key("CertificateStatuses") - if err := awsAwsjson11_serializeDocumentCertificateStatuses(v.CertificateStatuses, ok); err != nil { - return err - } - } - - if v.Includes != nil { - ok := object.Key("Includes") - if err := awsAwsjson11_serializeDocumentFilters(v.Includes, ok); err != nil { - return err - } - } - - if v.MaxItems != nil { - ok := object.Key("MaxItems") - ok.Integer(*v.MaxItems) - } - - if v.NextToken != nil { - ok := object.Key("NextToken") - ok.String(*v.NextToken) - } - - if len(v.SortBy) > 0 { - ok := object.Key("SortBy") - ok.String(string(v.SortBy)) - } - - if len(v.SortOrder) > 0 { - ok := object.Key("SortOrder") - ok.String(string(v.SortOrder)) - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentListTagsForCertificateInput(v *ListTagsForCertificateInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.CertificateArn != nil { - ok := object.Key("CertificateArn") - ok.String(*v.CertificateArn) - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentPutAccountConfigurationInput(v *PutAccountConfigurationInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.ExpiryEvents != nil { - ok := object.Key("ExpiryEvents") - if err := awsAwsjson11_serializeDocumentExpiryEventsConfiguration(v.ExpiryEvents, ok); err != nil { - return err - } - } - - if v.IdempotencyToken != nil { - ok := object.Key("IdempotencyToken") - ok.String(*v.IdempotencyToken) - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentRemoveTagsFromCertificateInput(v *RemoveTagsFromCertificateInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.CertificateArn != nil { - ok := object.Key("CertificateArn") - ok.String(*v.CertificateArn) - } - - if v.Tags != nil { - ok := object.Key("Tags") - if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil { - return err - } - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentRenewCertificateInput(v *RenewCertificateInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.CertificateArn != nil { - ok := object.Key("CertificateArn") - ok.String(*v.CertificateArn) - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentRequestCertificateInput(v *RequestCertificateInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.CertificateAuthorityArn != nil { - ok := object.Key("CertificateAuthorityArn") - ok.String(*v.CertificateAuthorityArn) - } - - if v.DomainName != nil { - ok := object.Key("DomainName") - ok.String(*v.DomainName) - } - - if v.DomainValidationOptions != nil { - ok := object.Key("DomainValidationOptions") - if err := awsAwsjson11_serializeDocumentDomainValidationOptionList(v.DomainValidationOptions, ok); err != nil { - return err - } - } - - if v.IdempotencyToken != nil { - ok := object.Key("IdempotencyToken") - ok.String(*v.IdempotencyToken) - } - - if len(v.KeyAlgorithm) > 0 { - ok := object.Key("KeyAlgorithm") - ok.String(string(v.KeyAlgorithm)) - } - - if len(v.ManagedBy) > 0 { - ok := object.Key("ManagedBy") - ok.String(string(v.ManagedBy)) - } - - if v.Options != nil { - ok := object.Key("Options") - if err := awsAwsjson11_serializeDocumentCertificateOptions(v.Options, ok); err != nil { - return err - } - } - - if v.SubjectAlternativeNames != nil { - ok := object.Key("SubjectAlternativeNames") - if err := awsAwsjson11_serializeDocumentDomainList(v.SubjectAlternativeNames, ok); err != nil { - return err - } - } - - if v.Tags != nil { - ok := object.Key("Tags") - if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil { - return err - } - } - - if len(v.ValidationMethod) > 0 { - ok := object.Key("ValidationMethod") - ok.String(string(v.ValidationMethod)) - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentResendValidationEmailInput(v *ResendValidationEmailInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.CertificateArn != nil { - ok := object.Key("CertificateArn") - ok.String(*v.CertificateArn) - } - - if v.Domain != nil { - ok := object.Key("Domain") - ok.String(*v.Domain) - } - - if v.ValidationDomain != nil { - ok := object.Key("ValidationDomain") - ok.String(*v.ValidationDomain) - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentRevokeCertificateInput(v *RevokeCertificateInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.CertificateArn != nil { - ok := object.Key("CertificateArn") - ok.String(*v.CertificateArn) - } - - if len(v.RevocationReason) > 0 { - ok := object.Key("RevocationReason") - ok.String(string(v.RevocationReason)) - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentSearchCertificatesInput(v *SearchCertificatesInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.FilterStatement != nil { - ok := object.Key("FilterStatement") - if err := awsAwsjson11_serializeDocumentCertificateFilterStatement(v.FilterStatement, ok); err != nil { - return err - } - } - - if v.MaxResults != nil { - ok := object.Key("MaxResults") - ok.Integer(*v.MaxResults) - } - - if v.NextToken != nil { - ok := object.Key("NextToken") - ok.String(*v.NextToken) - } - - if len(v.SortBy) > 0 { - ok := object.Key("SortBy") - ok.String(string(v.SortBy)) - } - - if len(v.SortOrder) > 0 { - ok := object.Key("SortOrder") - ok.String(string(v.SortOrder)) - } - - return nil -} - -func awsAwsjson11_serializeOpDocumentUpdateCertificateOptionsInput(v *UpdateCertificateOptionsInput, value smithyjson.Value) error { - object := value.Object() - defer object.Close() - - if v.CertificateArn != nil { - ok := object.Key("CertificateArn") - ok.String(*v.CertificateArn) - } - - if v.Options != nil { - ok := object.Key("Options") - if err := awsAwsjson11_serializeDocumentCertificateOptions(v.Options, ok); err != nil { - return err - } - } - - return nil -} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/type_registry.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/type_registry.go new file mode 100644 index 000000000..46cdbaef0 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/type_registry.go @@ -0,0 +1,87 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package acm + +import ( + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + "github.com/aws/aws-sdk-go-v2/service/acm/types" + smithy "github.com/aws/smithy-go" +) + +// TypeRegistry is the type registry for this service. +var TypeRegistry = &smithy.TypeRegistry{ + Entries: map[string]*smithy.TypeRegistryEntry{ + "com.amazonaws.acm#AccessDeniedException": { + Schema: schemas.AccessDeniedException, + New: func() any { return &types.AccessDeniedException{} }, + }, + "com.amazonaws.acm#ConflictException": { + Schema: schemas.ConflictException, + New: func() any { return &types.ConflictException{} }, + }, + "com.amazonaws.acm#InternalServerException": { + Schema: schemas.InternalServerException, + New: func() any { return &types.InternalServerException{} }, + }, + "com.amazonaws.acm#InvalidArgsException": { + Schema: schemas.InvalidArgsException, + New: func() any { return &types.InvalidArgsException{} }, + }, + "com.amazonaws.acm#InvalidArnException": { + Schema: schemas.InvalidArnException, + New: func() any { return &types.InvalidArnException{} }, + }, + "com.amazonaws.acm#InvalidDomainValidationOptionsException": { + Schema: schemas.InvalidDomainValidationOptionsException, + New: func() any { return &types.InvalidDomainValidationOptionsException{} }, + }, + "com.amazonaws.acm#InvalidParameterException": { + Schema: schemas.InvalidParameterException, + New: func() any { return &types.InvalidParameterException{} }, + }, + "com.amazonaws.acm#InvalidStateException": { + Schema: schemas.InvalidStateException, + New: func() any { return &types.InvalidStateException{} }, + }, + "com.amazonaws.acm#InvalidTagException": { + Schema: schemas.InvalidTagException, + New: func() any { return &types.InvalidTagException{} }, + }, + "com.amazonaws.acm#LimitExceededException": { + Schema: schemas.LimitExceededException, + New: func() any { return &types.LimitExceededException{} }, + }, + "com.amazonaws.acm#RequestInProgressException": { + Schema: schemas.RequestInProgressException, + New: func() any { return &types.RequestInProgressException{} }, + }, + "com.amazonaws.acm#ResourceInUseException": { + Schema: schemas.ResourceInUseException, + New: func() any { return &types.ResourceInUseException{} }, + }, + "com.amazonaws.acm#ResourceNotFoundException": { + Schema: schemas.ResourceNotFoundException, + New: func() any { return &types.ResourceNotFoundException{} }, + }, + "com.amazonaws.acm#ServiceQuotaExceededException": { + Schema: schemas.ServiceQuotaExceededException, + New: func() any { return &types.ServiceQuotaExceededException{} }, + }, + "com.amazonaws.acm#TagPolicyException": { + Schema: schemas.TagPolicyException, + New: func() any { return &types.TagPolicyException{} }, + }, + "com.amazonaws.acm#ThrottlingException": { + Schema: schemas.ThrottlingException, + New: func() any { return &types.ThrottlingException{} }, + }, + "com.amazonaws.acm#TooManyTagsException": { + Schema: schemas.TooManyTagsException, + New: func() any { return &types.TooManyTagsException{} }, + }, + "com.amazonaws.acm#ValidationException": { + Schema: schemas.ValidationException, + New: func() any { return &types.ValidationException{} }, + }, + }, +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/common_serde.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/common_serde.go new file mode 100644 index 000000000..31a3ff493 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/common_serde.go @@ -0,0 +1,1518 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package types + +import ( + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" +) + +func serializeAcmCertificateMetadataFilter(s smithy.ShapeSerializer, schema *smithy.Schema, v AcmCertificateMetadataFilter) { + switch vv := v.(type) { + case *AcmCertificateMetadataFilterMemberAcmeAccountId: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_AcmeAccountId) + s.WriteString(schemas.AcmCertificateMetadataFilter_AcmeAccountId, vv.Value) + s.CloseUnion() + case *AcmCertificateMetadataFilterMemberAcmeEndpointArn: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_AcmeEndpointArn) + s.WriteString(schemas.AcmCertificateMetadataFilter_AcmeEndpointArn, vv.Value) + s.CloseUnion() + case *AcmCertificateMetadataFilterMemberCertificateKeyPairOrigin: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_CertificateKeyPairOrigin) + s.WriteString(schemas.AcmCertificateMetadataFilter_CertificateKeyPairOrigin, string(vv.Value)) + s.CloseUnion() + case *AcmCertificateMetadataFilterMemberExportOption: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_ExportOption) + s.WriteString(schemas.AcmCertificateMetadataFilter_ExportOption, string(vv.Value)) + s.CloseUnion() + case *AcmCertificateMetadataFilterMemberExported: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_Exported) + s.WriteBool(schemas.AcmCertificateMetadataFilter_Exported, vv.Value) + s.CloseUnion() + case *AcmCertificateMetadataFilterMemberInUse: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_InUse) + s.WriteBool(schemas.AcmCertificateMetadataFilter_InUse, vv.Value) + s.CloseUnion() + case *AcmCertificateMetadataFilterMemberManagedBy: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_ManagedBy) + s.WriteString(schemas.AcmCertificateMetadataFilter_ManagedBy, string(vv.Value)) + s.CloseUnion() + case *AcmCertificateMetadataFilterMemberRenewalStatus: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_RenewalStatus) + s.WriteString(schemas.AcmCertificateMetadataFilter_RenewalStatus, string(vv.Value)) + s.CloseUnion() + case *AcmCertificateMetadataFilterMemberStatus: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_Status) + s.WriteString(schemas.AcmCertificateMetadataFilter_Status, string(vv.Value)) + s.CloseUnion() + case *AcmCertificateMetadataFilterMemberType: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_Type) + s.WriteString(schemas.AcmCertificateMetadataFilter_Type, string(vv.Value)) + s.CloseUnion() + case *AcmCertificateMetadataFilterMemberValidationMethod: + s.WriteUnion(schema, schemas.AcmCertificateMetadataFilter_ValidationMethod) + s.WriteString(schemas.AcmCertificateMetadataFilter_ValidationMethod, string(vv.Value)) + s.CloseUnion() + } +} + +func serializeCertificateAuthority(s smithy.ShapeSerializer, schema *smithy.Schema, v CertificateAuthority) { + switch vv := v.(type) { + case *CertificateAuthorityMemberPublicCertificateAuthority: + s.WriteUnion(schema, schemas.CertificateAuthority_PublicCertificateAuthority) + s.WriteStruct(schemas.CertificateAuthority_PublicCertificateAuthority) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializeCertificateFilter(s smithy.ShapeSerializer, schema *smithy.Schema, v CertificateFilter) { + switch vv := v.(type) { + case *CertificateFilterMemberAcmCertificateMetadataFilter: + s.WriteUnion(schema, schemas.CertificateFilter_AcmCertificateMetadataFilter) + serializeAcmCertificateMetadataFilter(s, schemas.CertificateFilter_AcmCertificateMetadataFilter, vv.Value) + s.CloseUnion() + case *CertificateFilterMemberCertificateArn: + s.WriteUnion(schema, schemas.CertificateFilter_CertificateArn) + s.WriteString(schemas.CertificateFilter_CertificateArn, vv.Value) + s.CloseUnion() + case *CertificateFilterMemberX509AttributeFilter: + s.WriteUnion(schema, schemas.CertificateFilter_X509AttributeFilter) + serializeX509AttributeFilter(s, schemas.CertificateFilter_X509AttributeFilter, vv.Value) + s.CloseUnion() + } +} + +func serializeCertificateFilterStatement(s smithy.ShapeSerializer, schema *smithy.Schema, v CertificateFilterStatement) { + switch vv := v.(type) { + case *CertificateFilterStatementMemberAnd: + s.WriteUnion(schema, schemas.CertificateFilterStatement_And) + serializeCertificateFilterStatementList(s, schemas.CertificateFilterStatement_And, vv.Value) + s.CloseUnion() + case *CertificateFilterStatementMemberFilter: + s.WriteUnion(schema, schemas.CertificateFilterStatement_Filter) + serializeCertificateFilter(s, schemas.CertificateFilterStatement_Filter, vv.Value) + s.CloseUnion() + case *CertificateFilterStatementMemberNot: + s.WriteUnion(schema, schemas.CertificateFilterStatement_Not) + serializeCertificateFilterStatement(s, schemas.CertificateFilterStatement_Not, vv.Value) + s.CloseUnion() + case *CertificateFilterStatementMemberOr: + s.WriteUnion(schema, schemas.CertificateFilterStatement_Or) + serializeCertificateFilterStatementList(s, schemas.CertificateFilterStatement_Or, vv.Value) + s.CloseUnion() + } +} + +func serializeCertificateMetadata(s smithy.ShapeSerializer, schema *smithy.Schema, v CertificateMetadata) { + switch vv := v.(type) { + case *CertificateMetadataMemberAcmCertificateMetadata: + s.WriteUnion(schema, schemas.CertificateMetadata_AcmCertificateMetadata) + s.WriteStruct(schemas.CertificateMetadata_AcmCertificateMetadata) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializeGeneralName(s smithy.ShapeSerializer, schema *smithy.Schema, v GeneralName) { + switch vv := v.(type) { + case *GeneralNameMemberDirectoryName: + s.WriteUnion(schema, schemas.GeneralName_DirectoryName) + s.WriteStruct(schemas.GeneralName_DirectoryName) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + case *GeneralNameMemberDnsName: + s.WriteUnion(schema, schemas.GeneralName_DnsName) + s.WriteString(schemas.GeneralName_DnsName, vv.Value) + s.CloseUnion() + case *GeneralNameMemberIpAddress: + s.WriteUnion(schema, schemas.GeneralName_IpAddress) + s.WriteString(schemas.GeneralName_IpAddress, vv.Value) + s.CloseUnion() + case *GeneralNameMemberOtherName: + s.WriteUnion(schema, schemas.GeneralName_OtherName) + s.WriteStruct(schemas.GeneralName_OtherName) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + case *GeneralNameMemberRegisteredId: + s.WriteUnion(schema, schemas.GeneralName_RegisteredId) + s.WriteString(schemas.GeneralName_RegisteredId, vv.Value) + s.CloseUnion() + case *GeneralNameMemberRfc822Name: + s.WriteUnion(schema, schemas.GeneralName_Rfc822Name) + s.WriteString(schemas.GeneralName_Rfc822Name, vv.Value) + s.CloseUnion() + case *GeneralNameMemberUniformResourceIdentifier: + s.WriteUnion(schema, schemas.GeneralName_UniformResourceIdentifier) + s.WriteString(schemas.GeneralName_UniformResourceIdentifier, vv.Value) + s.CloseUnion() + } +} + +func serializePrevalidationDetails(s smithy.ShapeSerializer, schema *smithy.Schema, v PrevalidationDetails) { + switch vv := v.(type) { + case *PrevalidationDetailsMemberDnsPrevalidation: + s.WriteUnion(schema, schemas.PrevalidationDetails_DnsPrevalidation) + s.WriteStruct(schemas.PrevalidationDetails_DnsPrevalidation) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializePrevalidationOptions(s smithy.ShapeSerializer, schema *smithy.Schema, v PrevalidationOptions) { + switch vv := v.(type) { + case *PrevalidationOptionsMemberDnsPrevalidation: + s.WriteUnion(schema, schemas.PrevalidationOptions_DnsPrevalidation) + s.WriteStruct(schemas.PrevalidationOptions_DnsPrevalidation) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializeSubjectAlternativeNameFilter(s smithy.ShapeSerializer, schema *smithy.Schema, v SubjectAlternativeNameFilter) { + switch vv := v.(type) { + case *SubjectAlternativeNameFilterMemberDnsName: + s.WriteUnion(schema, schemas.SubjectAlternativeNameFilter_DnsName) + s.WriteStruct(schemas.SubjectAlternativeNameFilter_DnsName) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializeSubjectFilter(s smithy.ShapeSerializer, schema *smithy.Schema, v SubjectFilter) { + switch vv := v.(type) { + case *SubjectFilterMemberCommonName: + s.WriteUnion(schema, schemas.SubjectFilter_CommonName) + s.WriteStruct(schemas.SubjectFilter_CommonName) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializeValidationChallenge(s smithy.ShapeSerializer, schema *smithy.Schema, v ValidationChallenge) { + switch vv := v.(type) { + case *ValidationChallengeMemberDnsValidationChallenge: + s.WriteUnion(schema, schemas.ValidationChallenge_DnsValidationChallenge) + s.WriteStruct(schemas.ValidationChallenge_DnsValidationChallenge) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + case *ValidationChallengeMemberEmailValidationChallenge: + s.WriteUnion(schema, schemas.ValidationChallenge_EmailValidationChallenge) + s.WriteStruct(schemas.ValidationChallenge_EmailValidationChallenge) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + } +} + +func serializeX509AttributeFilter(s smithy.ShapeSerializer, schema *smithy.Schema, v X509AttributeFilter) { + switch vv := v.(type) { + case *X509AttributeFilterMemberExtendedKeyUsage: + s.WriteUnion(schema, schemas.X509AttributeFilter_ExtendedKeyUsage) + s.WriteString(schemas.X509AttributeFilter_ExtendedKeyUsage, string(vv.Value)) + s.CloseUnion() + case *X509AttributeFilterMemberKeyAlgorithm: + s.WriteUnion(schema, schemas.X509AttributeFilter_KeyAlgorithm) + s.WriteString(schemas.X509AttributeFilter_KeyAlgorithm, string(vv.Value)) + s.CloseUnion() + case *X509AttributeFilterMemberKeyUsage: + s.WriteUnion(schema, schemas.X509AttributeFilter_KeyUsage) + s.WriteString(schemas.X509AttributeFilter_KeyUsage, string(vv.Value)) + s.CloseUnion() + case *X509AttributeFilterMemberNotAfter: + s.WriteUnion(schema, schemas.X509AttributeFilter_NotAfter) + s.WriteStruct(schemas.X509AttributeFilter_NotAfter) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + case *X509AttributeFilterMemberNotBefore: + s.WriteUnion(schema, schemas.X509AttributeFilter_NotBefore) + s.WriteStruct(schemas.X509AttributeFilter_NotBefore) + vv.Value.SerializeMembers(s) + s.CloseStruct() + s.CloseUnion() + case *X509AttributeFilterMemberSerialNumber: + s.WriteUnion(schema, schemas.X509AttributeFilter_SerialNumber) + s.WriteString(schemas.X509AttributeFilter_SerialNumber, vv.Value) + s.CloseUnion() + case *X509AttributeFilterMemberSubject: + s.WriteUnion(schema, schemas.X509AttributeFilter_Subject) + serializeSubjectFilter(s, schemas.X509AttributeFilter_Subject, vv.Value) + s.CloseUnion() + case *X509AttributeFilterMemberSubjectAlternativeName: + s.WriteUnion(schema, schemas.X509AttributeFilter_SubjectAlternativeName) + serializeSubjectAlternativeNameFilter(s, schemas.X509AttributeFilter_SubjectAlternativeName, vv.Value) + s.CloseUnion() + } +} + +func deserializeAcmCertificateMetadataFilter(d smithy.ShapeDeserializer, s *smithy.Schema, v *AcmCertificateMetadataFilter) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.AcmCertificateMetadataFilter_AcmeAccountId: + vv := &AcmCertificateMetadataFilterMemberAcmeAccountId{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_AcmeEndpointArn: + vv := &AcmCertificateMetadataFilterMemberAcmeEndpointArn{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_CertificateKeyPairOrigin: + vv := &AcmCertificateMetadataFilterMemberCertificateKeyPairOrigin{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_ExportOption: + vv := &AcmCertificateMetadataFilterMemberExportOption{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_Exported: + vv := &AcmCertificateMetadataFilterMemberExported{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_InUse: + vv := &AcmCertificateMetadataFilterMemberInUse{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_ManagedBy: + vv := &AcmCertificateMetadataFilterMemberManagedBy{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_RenewalStatus: + vv := &AcmCertificateMetadataFilterMemberRenewalStatus{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_Status: + vv := &AcmCertificateMetadataFilterMemberStatus{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_Type: + vv := &AcmCertificateMetadataFilterMemberType{} + *v = vv + return vv.Deserialize(d) + case schemas.AcmCertificateMetadataFilter_ValidationMethod: + vv := &AcmCertificateMetadataFilterMemberValidationMethod{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeCertificateAuthority(d smithy.ShapeDeserializer, s *smithy.Schema, v *CertificateAuthority) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.CertificateAuthority_PublicCertificateAuthority: + vv := &CertificateAuthorityMemberPublicCertificateAuthority{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeCertificateFilter(d smithy.ShapeDeserializer, s *smithy.Schema, v *CertificateFilter) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.CertificateFilter_AcmCertificateMetadataFilter: + vv := &CertificateFilterMemberAcmCertificateMetadataFilter{} + *v = vv + return vv.Deserialize(d) + case schemas.CertificateFilter_CertificateArn: + vv := &CertificateFilterMemberCertificateArn{} + *v = vv + return vv.Deserialize(d) + case schemas.CertificateFilter_X509AttributeFilter: + vv := &CertificateFilterMemberX509AttributeFilter{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeCertificateFilterStatement(d smithy.ShapeDeserializer, s *smithy.Schema, v *CertificateFilterStatement) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.CertificateFilterStatement_And: + vv := &CertificateFilterStatementMemberAnd{} + *v = vv + return vv.Deserialize(d) + case schemas.CertificateFilterStatement_Filter: + vv := &CertificateFilterStatementMemberFilter{} + *v = vv + return vv.Deserialize(d) + case schemas.CertificateFilterStatement_Not: + vv := &CertificateFilterStatementMemberNot{} + *v = vv + return vv.Deserialize(d) + case schemas.CertificateFilterStatement_Or: + vv := &CertificateFilterStatementMemberOr{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeCertificateMetadata(d smithy.ShapeDeserializer, s *smithy.Schema, v *CertificateMetadata) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.CertificateMetadata_AcmCertificateMetadata: + vv := &CertificateMetadataMemberAcmCertificateMetadata{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeGeneralName(d smithy.ShapeDeserializer, s *smithy.Schema, v *GeneralName) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.GeneralName_DirectoryName: + vv := &GeneralNameMemberDirectoryName{} + *v = vv + return vv.Deserialize(d) + case schemas.GeneralName_DnsName: + vv := &GeneralNameMemberDnsName{} + *v = vv + return vv.Deserialize(d) + case schemas.GeneralName_IpAddress: + vv := &GeneralNameMemberIpAddress{} + *v = vv + return vv.Deserialize(d) + case schemas.GeneralName_OtherName: + vv := &GeneralNameMemberOtherName{} + *v = vv + return vv.Deserialize(d) + case schemas.GeneralName_RegisteredId: + vv := &GeneralNameMemberRegisteredId{} + *v = vv + return vv.Deserialize(d) + case schemas.GeneralName_Rfc822Name: + vv := &GeneralNameMemberRfc822Name{} + *v = vv + return vv.Deserialize(d) + case schemas.GeneralName_UniformResourceIdentifier: + vv := &GeneralNameMemberUniformResourceIdentifier{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializePrevalidationDetails(d smithy.ShapeDeserializer, s *smithy.Schema, v *PrevalidationDetails) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.PrevalidationDetails_DnsPrevalidation: + vv := &PrevalidationDetailsMemberDnsPrevalidation{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializePrevalidationOptions(d smithy.ShapeDeserializer, s *smithy.Schema, v *PrevalidationOptions) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.PrevalidationOptions_DnsPrevalidation: + vv := &PrevalidationOptionsMemberDnsPrevalidation{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeSubjectAlternativeNameFilter(d smithy.ShapeDeserializer, s *smithy.Schema, v *SubjectAlternativeNameFilter) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.SubjectAlternativeNameFilter_DnsName: + vv := &SubjectAlternativeNameFilterMemberDnsName{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeSubjectFilter(d smithy.ShapeDeserializer, s *smithy.Schema, v *SubjectFilter) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.SubjectFilter_CommonName: + vv := &SubjectFilterMemberCommonName{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeValidationChallenge(d smithy.ShapeDeserializer, s *smithy.Schema, v *ValidationChallenge) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.ValidationChallenge_DnsValidationChallenge: + vv := &ValidationChallengeMemberDnsValidationChallenge{} + *v = vv + return vv.Deserialize(d) + case schemas.ValidationChallenge_EmailValidationChallenge: + vv := &ValidationChallengeMemberEmailValidationChallenge{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func deserializeX509AttributeFilter(d smithy.ShapeDeserializer, s *smithy.Schema, v *X509AttributeFilter) error { + return smithy.ReadUnion(d, s, func(ms *smithy.Schema) error { + switch ms { + case schemas.X509AttributeFilter_ExtendedKeyUsage: + vv := &X509AttributeFilterMemberExtendedKeyUsage{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_KeyAlgorithm: + vv := &X509AttributeFilterMemberKeyAlgorithm{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_KeyUsage: + vv := &X509AttributeFilterMemberKeyUsage{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_NotAfter: + vv := &X509AttributeFilterMemberNotAfter{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_NotBefore: + vv := &X509AttributeFilterMemberNotBefore{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_SerialNumber: + vv := &X509AttributeFilterMemberSerialNumber{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_Subject: + vv := &X509AttributeFilterMemberSubject{} + *v = vv + return vv.Deserialize(d) + case schemas.X509AttributeFilter_SubjectAlternativeName: + vv := &X509AttributeFilterMemberSubjectAlternativeName{} + *v = vv + return vv.Deserialize(d) + } + return nil + }) +} + +func serializeAcmeAccountList(s smithy.ShapeSerializer, schema *smithy.Schema, v []AcmeAccountSummary) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeAcmeDomainValidationList(s smithy.ShapeSerializer, schema *smithy.Schema, v []AcmeDomainValidationSummary) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeAcmeEndpointList(s smithy.ShapeSerializer, schema *smithy.Schema, v []AcmeEndpointSummary) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeAcmeExternalAccountBindingList(s smithy.ShapeSerializer, schema *smithy.Schema, v []AcmeExternalAccountBindingSummary) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeCertificateFilterStatementList(s smithy.ShapeSerializer, schema *smithy.Schema, v []CertificateFilterStatement) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + serializeCertificateFilterStatement(s, schema.ListMember(), vv) + } + s.CloseList() +} + +func serializeCertificateKeyPairOrigins(s smithy.ShapeSerializer, schema *smithy.Schema, v []CertificateKeyPairOrigin) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeCertificateSearchResultList(s smithy.ShapeSerializer, schema *smithy.Schema, v []CertificateSearchResult) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeCertificateStatuses(s smithy.ShapeSerializer, schema *smithy.Schema, v []CertificateStatus) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeCertificateSummaryList(s smithy.ShapeSerializer, schema *smithy.Schema, v []CertificateSummary) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeContactList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeCustomAttributeList(s smithy.ShapeSerializer, schema *smithy.Schema, v []CustomAttribute) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeDomainComponentList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeDomainList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeDomainValidationList(s smithy.ShapeSerializer, schema *smithy.Schema, v []DomainValidation) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeDomainValidationOptionList(s smithy.ShapeSerializer, schema *smithy.Schema, v []DomainValidationOption) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeDomainValidationSummaryList(s smithy.ShapeSerializer, schema *smithy.Schema, v []DomainValidationSummary) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeExtendedKeyUsageFilterList(s smithy.ShapeSerializer, schema *smithy.Schema, v []ExtendedKeyUsageName) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeExtendedKeyUsageList(s smithy.ShapeSerializer, schema *smithy.Schema, v []ExtendedKeyUsage) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeExtendedKeyUsageNames(s smithy.ShapeSerializer, schema *smithy.Schema, v []ExtendedKeyUsageName) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeGeneralNameList(s smithy.ShapeSerializer, schema *smithy.Schema, v []GeneralName) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + serializeGeneralName(s, schema.ListMember(), vv) + } + s.CloseList() +} + +func serializeInUseList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeKeyAlgorithmList(s smithy.ShapeSerializer, schema *smithy.Schema, v []KeyAlgorithm) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeKeyUsageFilterList(s smithy.ShapeSerializer, schema *smithy.Schema, v []KeyUsageName) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeKeyUsageList(s smithy.ShapeSerializer, schema *smithy.Schema, v []KeyUsage) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeKeyUsageNames(s smithy.ShapeSerializer, schema *smithy.Schema, v []KeyUsageName) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializePublicKeyAlgorithmList(s smithy.ShapeSerializer, schema *smithy.Schema, v []PublicKeyAlgorithm) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeTagKeyList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeTagList(s smithy.ShapeSerializer, schema *smithy.Schema, v []Tag) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeThrottlingReasonList(s smithy.ShapeSerializer, schema *smithy.Schema, v []ThrottlingReason) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeValidationEmailList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func deserializeAcmeAccountList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]AcmeAccountSummary) error { + *v = make([]AcmeAccountSummary, 0) + var vv AcmeAccountSummary + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero AcmeAccountSummary + *v = append(*v, zero) + return nil + } + + vv = AcmeAccountSummary{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeAcmeDomainValidationList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]AcmeDomainValidationSummary) error { + *v = make([]AcmeDomainValidationSummary, 0) + var vv AcmeDomainValidationSummary + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero AcmeDomainValidationSummary + *v = append(*v, zero) + return nil + } + + vv = AcmeDomainValidationSummary{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeAcmeEndpointList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]AcmeEndpointSummary) error { + *v = make([]AcmeEndpointSummary, 0) + var vv AcmeEndpointSummary + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero AcmeEndpointSummary + *v = append(*v, zero) + return nil + } + + vv = AcmeEndpointSummary{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeAcmeExternalAccountBindingList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]AcmeExternalAccountBindingSummary) error { + *v = make([]AcmeExternalAccountBindingSummary, 0) + var vv AcmeExternalAccountBindingSummary + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero AcmeExternalAccountBindingSummary + *v = append(*v, zero) + return nil + } + + vv = AcmeExternalAccountBindingSummary{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeCertificateFilterStatementList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]CertificateFilterStatement) error { + *v = make([]CertificateFilterStatement, 0) + var vv CertificateFilterStatement + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero CertificateFilterStatement + *v = append(*v, zero) + return nil + } + + if err := deserializeCertificateFilterStatement(d, s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeCertificateKeyPairOrigins(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]CertificateKeyPairOrigin) error { + *v = make([]CertificateKeyPairOrigin, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero CertificateKeyPairOrigin + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, CertificateKeyPairOrigin(vv)) + return nil + }) +} + +func deserializeCertificateSearchResultList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]CertificateSearchResult) error { + *v = make([]CertificateSearchResult, 0) + var vv CertificateSearchResult + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero CertificateSearchResult + *v = append(*v, zero) + return nil + } + + vv = CertificateSearchResult{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeCertificateStatuses(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]CertificateStatus) error { + *v = make([]CertificateStatus, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero CertificateStatus + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, CertificateStatus(vv)) + return nil + }) +} + +func deserializeCertificateSummaryList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]CertificateSummary) error { + *v = make([]CertificateSummary, 0) + var vv CertificateSummary + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero CertificateSummary + *v = append(*v, zero) + return nil + } + + vv = CertificateSummary{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeContactList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero string + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeCustomAttributeList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]CustomAttribute) error { + *v = make([]CustomAttribute, 0) + var vv CustomAttribute + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero CustomAttribute + *v = append(*v, zero) + return nil + } + + vv = CustomAttribute{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeDomainComponentList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero string + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeDomainList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero string + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeDomainValidationList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]DomainValidation) error { + *v = make([]DomainValidation, 0) + var vv DomainValidation + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero DomainValidation + *v = append(*v, zero) + return nil + } + + vv = DomainValidation{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeDomainValidationOptionList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]DomainValidationOption) error { + *v = make([]DomainValidationOption, 0) + var vv DomainValidationOption + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero DomainValidationOption + *v = append(*v, zero) + return nil + } + + vv = DomainValidationOption{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeDomainValidationSummaryList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]DomainValidationSummary) error { + *v = make([]DomainValidationSummary, 0) + var vv DomainValidationSummary + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero DomainValidationSummary + *v = append(*v, zero) + return nil + } + + vv = DomainValidationSummary{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeExtendedKeyUsageFilterList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]ExtendedKeyUsageName) error { + *v = make([]ExtendedKeyUsageName, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero ExtendedKeyUsageName + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, ExtendedKeyUsageName(vv)) + return nil + }) +} + +func deserializeExtendedKeyUsageList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]ExtendedKeyUsage) error { + *v = make([]ExtendedKeyUsage, 0) + var vv ExtendedKeyUsage + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero ExtendedKeyUsage + *v = append(*v, zero) + return nil + } + + vv = ExtendedKeyUsage{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeExtendedKeyUsageNames(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]ExtendedKeyUsageName) error { + *v = make([]ExtendedKeyUsageName, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero ExtendedKeyUsageName + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, ExtendedKeyUsageName(vv)) + return nil + }) +} + +func deserializeGeneralNameList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]GeneralName) error { + *v = make([]GeneralName, 0) + var vv GeneralName + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero GeneralName + *v = append(*v, zero) + return nil + } + + if err := deserializeGeneralName(d, s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeInUseList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero string + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeKeyAlgorithmList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]KeyAlgorithm) error { + *v = make([]KeyAlgorithm, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero KeyAlgorithm + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, KeyAlgorithm(vv)) + return nil + }) +} + +func deserializeKeyUsageFilterList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]KeyUsageName) error { + *v = make([]KeyUsageName, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero KeyUsageName + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, KeyUsageName(vv)) + return nil + }) +} + +func deserializeKeyUsageList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]KeyUsage) error { + *v = make([]KeyUsage, 0) + var vv KeyUsage + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero KeyUsage + *v = append(*v, zero) + return nil + } + + vv = KeyUsage{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeKeyUsageNames(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]KeyUsageName) error { + *v = make([]KeyUsageName, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero KeyUsageName + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, KeyUsageName(vv)) + return nil + }) +} + +func deserializePublicKeyAlgorithmList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]PublicKeyAlgorithm) error { + *v = make([]PublicKeyAlgorithm, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero PublicKeyAlgorithm + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, PublicKeyAlgorithm(vv)) + return nil + }) +} + +func deserializeTagKeyList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero string + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeTagList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]Tag) error { + *v = make([]Tag, 0) + var vv Tag + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero Tag + *v = append(*v, zero) + return nil + } + + vv = Tag{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeThrottlingReasonList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]ThrottlingReason) error { + *v = make([]ThrottlingReason, 0) + var vv ThrottlingReason + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero ThrottlingReason + *v = append(*v, zero) + return nil + } + + vv = ThrottlingReason{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeValidationEmailList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + if isNil, err := d.ReadNil(s.ListMember()); err != nil { + return err + } else if isNil { + var zero string + *v = append(*v, zero) + return nil + } + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/enums.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/enums.go index 0bba2cf89..f2493341d 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/enums.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/enums.go @@ -2,6 +2,143 @@ package types +type AcmeAccountStatus string + +// Enum values for AcmeAccountStatus +const ( + AcmeAccountStatusValid AcmeAccountStatus = "VALID" + AcmeAccountStatusDeactivated AcmeAccountStatus = "DEACTIVATED" + AcmeAccountStatusRevoked AcmeAccountStatus = "REVOKED" +) + +// Values returns all known values for AcmeAccountStatus. 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 (AcmeAccountStatus) Values() []AcmeAccountStatus { + return []AcmeAccountStatus{ + "VALID", + "DEACTIVATED", + "REVOKED", + } +} + +type AcmeAuthorizationBehavior string + +// Enum values for AcmeAuthorizationBehavior +const ( + AcmeAuthorizationBehaviorPreApproved AcmeAuthorizationBehavior = "PRE_APPROVED" +) + +// Values returns all known values for AcmeAuthorizationBehavior. 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 (AcmeAuthorizationBehavior) Values() []AcmeAuthorizationBehavior { + return []AcmeAuthorizationBehavior{ + "PRE_APPROVED", + } +} + +type AcmeContact string + +// Enum values for AcmeContact +const ( + AcmeContactRequired AcmeContact = "REQUIRED" + AcmeContactNotRequired AcmeContact = "NOT_REQUIRED" +) + +// Values returns all known values for AcmeContact. 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 (AcmeContact) Values() []AcmeContact { + return []AcmeContact{ + "REQUIRED", + "NOT_REQUIRED", + } +} + +type AcmeDomainValidationFailureReason string + +// Enum values for AcmeDomainValidationFailureReason +const ( + AcmeDomainValidationFailureReasonAccessDenied AcmeDomainValidationFailureReason = "ACCESS_DENIED" + AcmeDomainValidationFailureReasonDomainMismatch AcmeDomainValidationFailureReason = "DOMAIN_MISMATCH" + AcmeDomainValidationFailureReasonDomainNotAllowed AcmeDomainValidationFailureReason = "DOMAIN_NOT_ALLOWED" + AcmeDomainValidationFailureReasonEndpointNotActive AcmeDomainValidationFailureReason = "ENDPOINT_NOT_ACTIVE" + AcmeDomainValidationFailureReasonHostedZoneNotFound AcmeDomainValidationFailureReason = "HOSTED_ZONE_NOT_FOUND" + AcmeDomainValidationFailureReasonInternalFailure AcmeDomainValidationFailureReason = "INTERNAL_FAILURE" + AcmeDomainValidationFailureReasonInvalidChangeBatch AcmeDomainValidationFailureReason = "INVALID_CHANGE_BATCH" + AcmeDomainValidationFailureReasonInvalidPublicDomain AcmeDomainValidationFailureReason = "INVALID_PUBLIC_DOMAIN" + AcmeDomainValidationFailureReasonTimedOut AcmeDomainValidationFailureReason = "TIMED_OUT" +) + +// Values returns all known values for AcmeDomainValidationFailureReason. 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 (AcmeDomainValidationFailureReason) Values() []AcmeDomainValidationFailureReason { + return []AcmeDomainValidationFailureReason{ + "ACCESS_DENIED", + "DOMAIN_MISMATCH", + "DOMAIN_NOT_ALLOWED", + "ENDPOINT_NOT_ACTIVE", + "HOSTED_ZONE_NOT_FOUND", + "INTERNAL_FAILURE", + "INVALID_CHANGE_BATCH", + "INVALID_PUBLIC_DOMAIN", + "TIMED_OUT", + } +} + +type AcmeDomainValidationStatus string + +// Enum values for AcmeDomainValidationStatus +const ( + AcmeDomainValidationStatusValidating AcmeDomainValidationStatus = "VALIDATING" + AcmeDomainValidationStatusValid AcmeDomainValidationStatus = "VALID" + AcmeDomainValidationStatusInvalid AcmeDomainValidationStatus = "INVALID" + AcmeDomainValidationStatusDeleting AcmeDomainValidationStatus = "DELETING" +) + +// Values returns all known values for AcmeDomainValidationStatus. 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 (AcmeDomainValidationStatus) Values() []AcmeDomainValidationStatus { + return []AcmeDomainValidationStatus{ + "VALIDATING", + "VALID", + "INVALID", + "DELETING", + } +} + +type AcmeEndpointStatus string + +// Enum values for AcmeEndpointStatus +const ( + AcmeEndpointStatusCreating AcmeEndpointStatus = "CREATING" + AcmeEndpointStatusActive AcmeEndpointStatus = "ACTIVE" + AcmeEndpointStatusDeleting AcmeEndpointStatus = "DELETING" + AcmeEndpointStatusFailed AcmeEndpointStatus = "FAILED" +) + +// Values returns all known values for AcmeEndpointStatus. 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 (AcmeEndpointStatus) Values() []AcmeEndpointStatus { + return []AcmeEndpointStatus{ + "CREATING", + "ACTIVE", + "DELETING", + "FAILED", + } +} + type CertificateExport string // Enum values for CertificateExport @@ -21,6 +158,27 @@ func (CertificateExport) Values() []CertificateExport { } } +type CertificateKeyPairOrigin string + +// Enum values for CertificateKeyPairOrigin +const ( + CertificateKeyPairOriginAwsManaged CertificateKeyPairOrigin = "AWS_MANAGED" + CertificateKeyPairOriginAcme CertificateKeyPairOrigin = "ACME" + CertificateKeyPairOriginCustomerProvided CertificateKeyPairOrigin = "CUSTOMER_PROVIDED" +) + +// Values returns all known values for CertificateKeyPairOrigin. 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 (CertificateKeyPairOrigin) Values() []CertificateKeyPairOrigin { + return []CertificateKeyPairOrigin{ + "AWS_MANAGED", + "ACME", + "CUSTOMER_PROVIDED", + } +} + type CertificateManagedBy string // Enum values for CertificateManagedBy @@ -127,6 +285,25 @@ func (ComparisonOperator) Values() []ComparisonOperator { } } +type DomainScopeOption string + +// Enum values for DomainScopeOption +const ( + DomainScopeOptionEnabled DomainScopeOption = "ENABLED" + DomainScopeOptionDisabled DomainScopeOption = "DISABLED" +) + +// Values returns all known values for DomainScopeOption. 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 (DomainScopeOption) Values() []DomainScopeOption { + return []DomainScopeOption{ + "ENABLED", + "DISABLED", + } +} + type DomainStatus string // Enum values for DomainStatus @@ -302,6 +479,44 @@ func (KeyUsageName) Values() []KeyUsageName { } } +type PrevalidationType string + +// Enum values for PrevalidationType +const ( + PrevalidationTypeDnsPrevalidation PrevalidationType = "DNS_PREVALIDATION" +) + +// Values returns all known values for PrevalidationType. 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 (PrevalidationType) Values() []PrevalidationType { + return []PrevalidationType{ + "DNS_PREVALIDATION", + } +} + +type PublicKeyAlgorithm string + +// Enum values for PublicKeyAlgorithm +const ( + PublicKeyAlgorithmRsa2048 PublicKeyAlgorithm = "RSA_2048" + PublicKeyAlgorithmEcPrime256V1 PublicKeyAlgorithm = "EC_prime256v1" + PublicKeyAlgorithmEcSecp384R1 PublicKeyAlgorithm = "EC_secp384r1" +) + +// Values returns all known values for PublicKeyAlgorithm. 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 (PublicKeyAlgorithm) Values() []PublicKeyAlgorithm { + return []PublicKeyAlgorithm{ + "RSA_2048", + "EC_prime256v1", + "EC_secp384r1", + } +} + type RecordType string // Enum values for RecordType @@ -402,24 +617,27 @@ type SearchCertificatesSortBy string // Enum values for SearchCertificatesSortBy const ( - SearchCertificatesSortByCreatedAt SearchCertificatesSortBy = "CREATED_AT" - SearchCertificatesSortByNotAfter SearchCertificatesSortBy = "NOT_AFTER" - SearchCertificatesSortByStatus SearchCertificatesSortBy = "STATUS" - SearchCertificatesSortByRenewalStatus SearchCertificatesSortBy = "RENEWAL_STATUS" - SearchCertificatesSortByExported SearchCertificatesSortBy = "EXPORTED" - SearchCertificatesSortByInUse SearchCertificatesSortBy = "IN_USE" - SearchCertificatesSortByNotBefore SearchCertificatesSortBy = "NOT_BEFORE" - SearchCertificatesSortByKeyAlgorithm SearchCertificatesSortBy = "KEY_ALGORITHM" - SearchCertificatesSortByType SearchCertificatesSortBy = "TYPE" - SearchCertificatesSortByCertificateArn SearchCertificatesSortBy = "CERTIFICATE_ARN" - SearchCertificatesSortByCommonName SearchCertificatesSortBy = "COMMON_NAME" - SearchCertificatesSortByRevokedAt SearchCertificatesSortBy = "REVOKED_AT" - SearchCertificatesSortByRenewalEligibility SearchCertificatesSortBy = "RENEWAL_ELIGIBILITY" - SearchCertificatesSortByIssuedAt SearchCertificatesSortBy = "ISSUED_AT" - SearchCertificatesSortByManagedBy SearchCertificatesSortBy = "MANAGED_BY" - SearchCertificatesSortByExportOption SearchCertificatesSortBy = "EXPORT_OPTION" - SearchCertificatesSortByValidationMethod SearchCertificatesSortBy = "VALIDATION_METHOD" - SearchCertificatesSortByImportedAt SearchCertificatesSortBy = "IMPORTED_AT" + SearchCertificatesSortByCreatedAt SearchCertificatesSortBy = "CREATED_AT" + SearchCertificatesSortByNotAfter SearchCertificatesSortBy = "NOT_AFTER" + SearchCertificatesSortByStatus SearchCertificatesSortBy = "STATUS" + SearchCertificatesSortByRenewalStatus SearchCertificatesSortBy = "RENEWAL_STATUS" + SearchCertificatesSortByExported SearchCertificatesSortBy = "EXPORTED" + SearchCertificatesSortByInUse SearchCertificatesSortBy = "IN_USE" + SearchCertificatesSortByNotBefore SearchCertificatesSortBy = "NOT_BEFORE" + SearchCertificatesSortByKeyAlgorithm SearchCertificatesSortBy = "KEY_ALGORITHM" + SearchCertificatesSortByType SearchCertificatesSortBy = "TYPE" + SearchCertificatesSortByCertificateArn SearchCertificatesSortBy = "CERTIFICATE_ARN" + SearchCertificatesSortByCommonName SearchCertificatesSortBy = "COMMON_NAME" + SearchCertificatesSortByRevokedAt SearchCertificatesSortBy = "REVOKED_AT" + SearchCertificatesSortByRenewalEligibility SearchCertificatesSortBy = "RENEWAL_ELIGIBILITY" + SearchCertificatesSortByIssuedAt SearchCertificatesSortBy = "ISSUED_AT" + SearchCertificatesSortByManagedBy SearchCertificatesSortBy = "MANAGED_BY" + SearchCertificatesSortByExportOption SearchCertificatesSortBy = "EXPORT_OPTION" + SearchCertificatesSortByValidationMethod SearchCertificatesSortBy = "VALIDATION_METHOD" + SearchCertificatesSortByImportedAt SearchCertificatesSortBy = "IMPORTED_AT" + SearchCertificatesSortByAcmeEndpointArn SearchCertificatesSortBy = "ACME_ENDPOINT_ARN" + SearchCertificatesSortByAcmeAccountId SearchCertificatesSortBy = "ACME_ACCOUNT_ID" + SearchCertificatesSortByCertificateKeyPairOrigin SearchCertificatesSortBy = "CERTIFICATE_KEY_PAIR_ORIGIN" ) // Values returns all known values for SearchCertificatesSortBy. Note that this @@ -446,6 +664,9 @@ func (SearchCertificatesSortBy) Values() []SearchCertificatesSortBy { "EXPORT_OPTION", "VALIDATION_METHOD", "IMPORTED_AT", + "ACME_ENDPOINT_ARN", + "ACME_ACCOUNT_ID", + "CERTIFICATE_KEY_PAIR_ORIGIN", } } @@ -504,6 +725,65 @@ func (SortOrder) Values() []SortOrder { } } +type TimeType string + +// Enum values for TimeType +const ( + TimeTypeMinutes TimeType = "MINUTES" + TimeTypeHours TimeType = "HOURS" + TimeTypeDays TimeType = "DAYS" +) + +// Values returns all known values for TimeType. 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 (TimeType) Values() []TimeType { + return []TimeType{ + "MINUTES", + "HOURS", + "DAYS", + } +} + +type UpdateStatus string + +// Enum values for UpdateStatus +const ( + UpdateStatusPendingDomainValidation UpdateStatus = "PENDING_DOMAIN_VALIDATION" + UpdateStatusSuccess UpdateStatus = "SUCCESS" + UpdateStatusFailed UpdateStatus = "FAILED" +) + +// Values returns all known values for UpdateStatus. 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 (UpdateStatus) Values() []UpdateStatus { + return []UpdateStatus{ + "PENDING_DOMAIN_VALIDATION", + "SUCCESS", + "FAILED", + } +} + +type UpdateType string + +// Enum values for UpdateType +const ( + UpdateTypeDomainValidationMethod UpdateType = "DOMAIN_VALIDATION_METHOD" +) + +// Values returns all known values for UpdateType. 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 (UpdateType) Values() []UpdateType { + return []UpdateType{ + "DOMAIN_VALIDATION_METHOD", + } +} + type ValidationMethod string // Enum values for ValidationMethod diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/errors.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/errors.go index 15fffbd14..22e39f6a0 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/errors.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/errors.go @@ -4,6 +4,7 @@ package types import ( "fmt" + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" smithy "github.com/aws/smithy-go" ) @@ -32,6 +33,27 @@ func (e *AccessDeniedException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *AccessDeniedException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.AccessDeniedException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *AccessDeniedException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.AccessDeniedException_Message, *v.Message) + } +} +func (v *AccessDeniedException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.AccessDeniedException, func(s *smithy.Schema) error { + switch s { + case schemas.AccessDeniedException_Message: + v.Message = new(string) + return d.ReadString(schemas.AccessDeniedException_Message, v.Message) + } + return nil + }) +} // You are trying to update a resource or configuration that is already being // created or updated. Wait for the previous operation to finish and try again. @@ -59,6 +81,75 @@ func (e *ConflictException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *ConflictException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *ConflictException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ConflictException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ConflictException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.ConflictException_message, *v.Message) + } +} +func (v *ConflictException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ConflictException, func(s *smithy.Schema) error { + switch s { + case schemas.ConflictException_message: + v.Message = new(string) + return d.ReadString(schemas.ConflictException_message, v.Message) + } + return nil + }) +} + +// The request processing has failed because of an unknown error, exception, or +// failure. +type InternalServerException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *InternalServerException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *InternalServerException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *InternalServerException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "InternalServerException" + } + return *e.ErrorCodeOverride +} +func (e *InternalServerException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer } +func (v *InternalServerException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.InternalServerException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *InternalServerException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.InternalServerException_message, *v.Message) + } +} +func (v *InternalServerException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.InternalServerException, func(s *smithy.Schema) error { + switch s { + case schemas.InternalServerException_message: + v.Message = new(string) + return d.ReadString(schemas.InternalServerException_message, v.Message) + } + return nil + }) +} // One or more of request parameters specified is not valid. type InvalidArgsException struct { @@ -85,6 +176,27 @@ func (e *InvalidArgsException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *InvalidArgsException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *InvalidArgsException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.InvalidArgsException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *InvalidArgsException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.InvalidArgsException_message, *v.Message) + } +} +func (v *InvalidArgsException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.InvalidArgsException, func(s *smithy.Schema) error { + switch s { + case schemas.InvalidArgsException_message: + v.Message = new(string) + return d.ReadString(schemas.InvalidArgsException_message, v.Message) + } + return nil + }) +} // The requested Amazon Resource Name (ARN) does not refer to an existing resource. type InvalidArnException struct { @@ -111,6 +223,27 @@ func (e *InvalidArnException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *InvalidArnException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *InvalidArnException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.InvalidArnException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *InvalidArnException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.InvalidArnException_message, *v.Message) + } +} +func (v *InvalidArnException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.InvalidArnException, func(s *smithy.Schema) error { + switch s { + case schemas.InvalidArnException_message: + v.Message = new(string) + return d.ReadString(schemas.InvalidArnException_message, v.Message) + } + return nil + }) +} // One or more values in the DomainValidationOption structure is incorrect. type InvalidDomainValidationOptionsException struct { @@ -139,6 +272,27 @@ func (e *InvalidDomainValidationOptionsException) ErrorCode() string { func (e *InvalidDomainValidationOptionsException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *InvalidDomainValidationOptionsException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.InvalidDomainValidationOptionsException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *InvalidDomainValidationOptionsException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.InvalidDomainValidationOptionsException_message, *v.Message) + } +} +func (v *InvalidDomainValidationOptionsException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.InvalidDomainValidationOptionsException, func(s *smithy.Schema) error { + switch s { + case schemas.InvalidDomainValidationOptionsException_message: + v.Message = new(string) + return d.ReadString(schemas.InvalidDomainValidationOptionsException_message, v.Message) + } + return nil + }) +} // An input parameter was invalid. type InvalidParameterException struct { @@ -165,6 +319,27 @@ func (e *InvalidParameterException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *InvalidParameterException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *InvalidParameterException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.InvalidParameterException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *InvalidParameterException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.InvalidParameterException_message, *v.Message) + } +} +func (v *InvalidParameterException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.InvalidParameterException, func(s *smithy.Schema) error { + switch s { + case schemas.InvalidParameterException_message: + v.Message = new(string) + return d.ReadString(schemas.InvalidParameterException_message, v.Message) + } + return nil + }) +} // Processing has reached an invalid state. type InvalidStateException struct { @@ -191,6 +366,27 @@ func (e *InvalidStateException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *InvalidStateException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *InvalidStateException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.InvalidStateException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *InvalidStateException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.InvalidStateException_message, *v.Message) + } +} +func (v *InvalidStateException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.InvalidStateException, func(s *smithy.Schema) error { + switch s { + case schemas.InvalidStateException_message: + v.Message = new(string) + return d.ReadString(schemas.InvalidStateException_message, v.Message) + } + return nil + }) +} // One or both of the values that make up the key-value pair is not valid. For // example, you cannot specify a tag value that begins with aws: . @@ -218,6 +414,27 @@ func (e *InvalidTagException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *InvalidTagException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *InvalidTagException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.InvalidTagException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *InvalidTagException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.InvalidTagException_message, *v.Message) + } +} +func (v *InvalidTagException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.InvalidTagException, func(s *smithy.Schema) error { + switch s { + case schemas.InvalidTagException_message: + v.Message = new(string) + return d.ReadString(schemas.InvalidTagException_message, v.Message) + } + return nil + }) +} // An ACM quota has been exceeded. type LimitExceededException struct { @@ -244,6 +461,27 @@ func (e *LimitExceededException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *LimitExceededException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *LimitExceededException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.LimitExceededException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *LimitExceededException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.LimitExceededException_message, *v.Message) + } +} +func (v *LimitExceededException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.LimitExceededException, func(s *smithy.Schema) error { + switch s { + case schemas.LimitExceededException_message: + v.Message = new(string) + return d.ReadString(schemas.LimitExceededException_message, v.Message) + } + return nil + }) +} // The certificate request is in process and the certificate in your account has // not yet been issued. @@ -271,6 +509,27 @@ func (e *RequestInProgressException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *RequestInProgressException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *RequestInProgressException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RequestInProgressException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RequestInProgressException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.RequestInProgressException_message, *v.Message) + } +} +func (v *RequestInProgressException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RequestInProgressException, func(s *smithy.Schema) error { + switch s { + case schemas.RequestInProgressException_message: + v.Message = new(string) + return d.ReadString(schemas.RequestInProgressException_message, v.Message) + } + return nil + }) +} // The certificate is in use by another Amazon Web Services service in the // caller's account. Remove the association and try again. @@ -298,6 +557,27 @@ func (e *ResourceInUseException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *ResourceInUseException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *ResourceInUseException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ResourceInUseException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ResourceInUseException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.ResourceInUseException_message, *v.Message) + } +} +func (v *ResourceInUseException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ResourceInUseException, func(s *smithy.Schema) error { + switch s { + case schemas.ResourceInUseException_message: + v.Message = new(string) + return d.ReadString(schemas.ResourceInUseException_message, v.Message) + } + return nil + }) +} // The specified certificate cannot be found in the caller's account or the // caller's account cannot be found. @@ -325,6 +605,74 @@ func (e *ResourceNotFoundException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *ResourceNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *ResourceNotFoundException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ResourceNotFoundException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ResourceNotFoundException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.ResourceNotFoundException_message, *v.Message) + } +} +func (v *ResourceNotFoundException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ResourceNotFoundException, func(s *smithy.Schema) error { + switch s { + case schemas.ResourceNotFoundException_message: + v.Message = new(string) + return d.ReadString(schemas.ResourceNotFoundException_message, v.Message) + } + return nil + }) +} + +// A service quota has been exceeded. +type ServiceQuotaExceededException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *ServiceQuotaExceededException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *ServiceQuotaExceededException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *ServiceQuotaExceededException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "ServiceQuotaExceededException" + } + return *e.ErrorCodeOverride +} +func (e *ServiceQuotaExceededException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *ServiceQuotaExceededException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ServiceQuotaExceededException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ServiceQuotaExceededException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.ServiceQuotaExceededException_message, *v.Message) + } +} +func (v *ServiceQuotaExceededException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ServiceQuotaExceededException, func(s *smithy.Schema) error { + switch s { + case schemas.ServiceQuotaExceededException_message: + v.Message = new(string) + return d.ReadString(schemas.ServiceQuotaExceededException_message, v.Message) + } + return nil + }) +} // A specified tag did not comply with an existing tag policy and was rejected. type TagPolicyException struct { @@ -351,6 +699,27 @@ func (e *TagPolicyException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *TagPolicyException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *TagPolicyException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.TagPolicyException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *TagPolicyException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.TagPolicyException_message, *v.Message) + } +} +func (v *TagPolicyException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.TagPolicyException, func(s *smithy.Schema) error { + switch s { + case schemas.TagPolicyException_message: + v.Message = new(string) + return d.ReadString(schemas.TagPolicyException_message, v.Message) + } + return nil + }) +} // The request was denied because it exceeded a quota. type ThrottlingException struct { @@ -379,6 +748,30 @@ func (e *ThrottlingException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *ThrottlingException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *ThrottlingException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ThrottlingException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ThrottlingException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.ThrottlingException_message, *v.Message) + } + serializeThrottlingReasonList(s, schemas.ThrottlingException_throttlingReasons, v.ThrottlingReasons) +} +func (v *ThrottlingException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ThrottlingException, func(s *smithy.Schema) error { + switch s { + case schemas.ThrottlingException_message: + v.Message = new(string) + return d.ReadString(schemas.ThrottlingException_message, v.Message) + case schemas.ThrottlingException_throttlingReasons: + return deserializeThrottlingReasonList(d, schemas.ThrottlingException_throttlingReasons, &v.ThrottlingReasons) + } + return nil + }) +} // The request contains too many tags. Try the request again with fewer tags. type TooManyTagsException struct { @@ -405,6 +798,27 @@ func (e *TooManyTagsException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *TooManyTagsException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *TooManyTagsException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.TooManyTagsException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *TooManyTagsException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.TooManyTagsException_message, *v.Message) + } +} +func (v *TooManyTagsException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.TooManyTagsException, func(s *smithy.Schema) error { + switch s { + case schemas.TooManyTagsException_message: + v.Message = new(string) + return d.ReadString(schemas.TooManyTagsException_message, v.Message) + } + return nil + }) +} // The supplied input failed to satisfy constraints of an Amazon Web Services // service. @@ -432,3 +846,24 @@ func (e *ValidationException) ErrorCode() string { return *e.ErrorCodeOverride } func (e *ValidationException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *ValidationException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ValidationException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ValidationException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.ValidationException_message, *v.Message) + } +} +func (v *ValidationException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ValidationException, func(s *smithy.Schema) error { + switch s { + case schemas.ValidationException_message: + v.Message = new(string) + return d.ReadString(schemas.ValidationException_message, v.Message) + } + return nil + }) +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/types.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/types.go index cbcc1c57f..89581d7a8 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/types.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/types/types.go @@ -3,6 +3,8 @@ package types import ( + "github.com/aws/aws-sdk-go-v2/service/acm/schemas" + smithy "github.com/aws/smithy-go" smithydocument "github.com/aws/smithy-go/document" "time" ) @@ -10,6 +12,15 @@ import ( // Contains ACM-specific metadata about a certificate. type AcmCertificateMetadata struct { + // The ACME account identifier associated with the certificate. + AcmeAccountId *string + + // The ARN of the ACME endpoint used to issue the certificate. + AcmeEndpointArn *string + + // The origin of the certificate's key pair. + CertificateKeyPairOrigin CertificateKeyPairOrigin + // The time at which the certificate was requested. CreatedAt *time.Time @@ -76,10 +87,157 @@ type AcmCertificateMetadata struct { noSmithyDocumentSerde } +func (v *AcmCertificateMetadata) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.AcmCertificateMetadata) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *AcmCertificateMetadata) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeAccountId != nil { + s.WriteString(schemas.AcmCertificateMetadata_AcmeAccountId, *v.AcmeAccountId) + } + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.AcmCertificateMetadata_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.CertificateKeyPairOrigin != "" { + s.WriteString(schemas.AcmCertificateMetadata_CertificateKeyPairOrigin, string(v.CertificateKeyPairOrigin)) + } + if v.CreatedAt != nil { + s.WriteTime(schemas.AcmCertificateMetadata_CreatedAt, *v.CreatedAt) + } + if v.ExportOption != "" { + s.WriteString(schemas.AcmCertificateMetadata_ExportOption, string(v.ExportOption)) + } + if v.Exported != nil { + s.WriteBool(schemas.AcmCertificateMetadata_Exported, *v.Exported) + } + if v.ImportedAt != nil { + s.WriteTime(schemas.AcmCertificateMetadata_ImportedAt, *v.ImportedAt) + } + if v.InUse != nil { + s.WriteBool(schemas.AcmCertificateMetadata_InUse, *v.InUse) + } + if v.IssuedAt != nil { + s.WriteTime(schemas.AcmCertificateMetadata_IssuedAt, *v.IssuedAt) + } + if v.ManagedBy != "" { + s.WriteString(schemas.AcmCertificateMetadata_ManagedBy, string(v.ManagedBy)) + } + if v.RenewalEligibility != "" { + s.WriteString(schemas.AcmCertificateMetadata_RenewalEligibility, string(v.RenewalEligibility)) + } + if v.RenewalStatus != "" { + s.WriteString(schemas.AcmCertificateMetadata_RenewalStatus, string(v.RenewalStatus)) + } + if v.RevokedAt != nil { + s.WriteTime(schemas.AcmCertificateMetadata_RevokedAt, *v.RevokedAt) + } + if v.Status != "" { + s.WriteString(schemas.AcmCertificateMetadata_Status, string(v.Status)) + } + if v.Type != "" { + s.WriteString(schemas.AcmCertificateMetadata_Type, string(v.Type)) + } + if v.ValidationMethod != "" { + s.WriteString(schemas.AcmCertificateMetadata_ValidationMethod, string(v.ValidationMethod)) + } +} +func (v *AcmCertificateMetadata) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.AcmCertificateMetadata, func(s *smithy.Schema) error { + switch s { + case schemas.AcmCertificateMetadata_AcmeAccountId: + v.AcmeAccountId = new(string) + return d.ReadString(schemas.AcmCertificateMetadata_AcmeAccountId, v.AcmeAccountId) + case schemas.AcmCertificateMetadata_AcmeEndpointArn: + v.AcmeEndpointArn = new(string) + return d.ReadString(schemas.AcmCertificateMetadata_AcmeEndpointArn, v.AcmeEndpointArn) + case schemas.AcmCertificateMetadata_CertificateKeyPairOrigin: + var ev string + if err := d.ReadString(schemas.AcmCertificateMetadata_CertificateKeyPairOrigin, &ev); err != nil { + return err + } + v.CertificateKeyPairOrigin = CertificateKeyPairOrigin(ev) + return nil + case schemas.AcmCertificateMetadata_CreatedAt: + v.CreatedAt = new(time.Time) + return d.ReadTime(schemas.AcmCertificateMetadata_CreatedAt, v.CreatedAt) + case schemas.AcmCertificateMetadata_ExportOption: + var ev string + if err := d.ReadString(schemas.AcmCertificateMetadata_ExportOption, &ev); err != nil { + return err + } + v.ExportOption = CertificateExport(ev) + return nil + case schemas.AcmCertificateMetadata_Exported: + v.Exported = new(bool) + return d.ReadBool(schemas.AcmCertificateMetadata_Exported, v.Exported) + case schemas.AcmCertificateMetadata_ImportedAt: + v.ImportedAt = new(time.Time) + return d.ReadTime(schemas.AcmCertificateMetadata_ImportedAt, v.ImportedAt) + case schemas.AcmCertificateMetadata_InUse: + v.InUse = new(bool) + return d.ReadBool(schemas.AcmCertificateMetadata_InUse, v.InUse) + case schemas.AcmCertificateMetadata_IssuedAt: + v.IssuedAt = new(time.Time) + return d.ReadTime(schemas.AcmCertificateMetadata_IssuedAt, v.IssuedAt) + case schemas.AcmCertificateMetadata_ManagedBy: + var ev string + if err := d.ReadString(schemas.AcmCertificateMetadata_ManagedBy, &ev); err != nil { + return err + } + v.ManagedBy = CertificateManagedBy(ev) + return nil + case schemas.AcmCertificateMetadata_RenewalEligibility: + var ev string + if err := d.ReadString(schemas.AcmCertificateMetadata_RenewalEligibility, &ev); err != nil { + return err + } + v.RenewalEligibility = RenewalEligibility(ev) + return nil + case schemas.AcmCertificateMetadata_RenewalStatus: + var ev string + if err := d.ReadString(schemas.AcmCertificateMetadata_RenewalStatus, &ev); err != nil { + return err + } + v.RenewalStatus = RenewalStatus(ev) + return nil + case schemas.AcmCertificateMetadata_RevokedAt: + v.RevokedAt = new(time.Time) + return d.ReadTime(schemas.AcmCertificateMetadata_RevokedAt, v.RevokedAt) + case schemas.AcmCertificateMetadata_Status: + var ev string + if err := d.ReadString(schemas.AcmCertificateMetadata_Status, &ev); err != nil { + return err + } + v.Status = CertificateStatus(ev) + return nil + case schemas.AcmCertificateMetadata_Type: + var ev string + if err := d.ReadString(schemas.AcmCertificateMetadata_Type, &ev); err != nil { + return err + } + v.Type = CertificateType(ev) + return nil + case schemas.AcmCertificateMetadata_ValidationMethod: + var ev string + if err := d.ReadString(schemas.AcmCertificateMetadata_ValidationMethod, &ev); err != nil { + return err + } + v.ValidationMethod = ValidationMethod(ev) + return nil + } + return nil + }) +} + // Filters certificates by ACM metadata. // // The following types satisfy this interface: // +// AcmCertificateMetadataFilterMemberAcmeAccountId +// AcmCertificateMetadataFilterMemberAcmeEndpointArn +// AcmCertificateMetadataFilterMemberCertificateKeyPairOrigin // AcmCertificateMetadataFilterMemberExported // AcmCertificateMetadataFilterMemberExportOption // AcmCertificateMetadataFilterMemberInUse @@ -92,6 +250,56 @@ type AcmCertificateMetadataFilter interface { isAcmCertificateMetadataFilter() } +// Filter by ACME account identifier. +type AcmCertificateMetadataFilterMemberAcmeAccountId struct { + Value string + + noSmithyDocumentSerde +} + +func (*AcmCertificateMetadataFilterMemberAcmeAccountId) isAcmCertificateMetadataFilter() {} +func (v *AcmCertificateMetadataFilterMemberAcmeAccountId) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.AcmCertificateMetadataFilter_AcmeAccountId, v.Value) +} +func (v *AcmCertificateMetadataFilterMemberAcmeAccountId) Deserialize(d smithy.ShapeDeserializer) error { + return d.ReadString(schemas.AcmCertificateMetadataFilter_AcmeAccountId, &v.Value) +} + +// Filter by ACME endpoint ARN. +type AcmCertificateMetadataFilterMemberAcmeEndpointArn struct { + Value string + + noSmithyDocumentSerde +} + +func (*AcmCertificateMetadataFilterMemberAcmeEndpointArn) isAcmCertificateMetadataFilter() {} +func (v *AcmCertificateMetadataFilterMemberAcmeEndpointArn) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.AcmCertificateMetadataFilter_AcmeEndpointArn, v.Value) +} +func (v *AcmCertificateMetadataFilterMemberAcmeEndpointArn) Deserialize(d smithy.ShapeDeserializer) error { + return d.ReadString(schemas.AcmCertificateMetadataFilter_AcmeEndpointArn, &v.Value) +} + +// Filter by certificate key pair origin. +type AcmCertificateMetadataFilterMemberCertificateKeyPairOrigin struct { + Value CertificateKeyPairOrigin + + noSmithyDocumentSerde +} + +func (*AcmCertificateMetadataFilterMemberCertificateKeyPairOrigin) isAcmCertificateMetadataFilter() {} +func (v *AcmCertificateMetadataFilterMemberCertificateKeyPairOrigin) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.AcmCertificateMetadataFilter_CertificateKeyPairOrigin, string(v.Value)) +} +func (v *AcmCertificateMetadataFilterMemberCertificateKeyPairOrigin) Deserialize(d smithy.ShapeDeserializer) error { + var s string + if err := d.ReadString(schemas.AcmCertificateMetadataFilter_CertificateKeyPairOrigin, &s); err != nil { + return err + } + v.Value = CertificateKeyPairOrigin(s) + return nil +} + // Filter by whether the certificate has been exported. type AcmCertificateMetadataFilterMemberExported struct { Value bool @@ -100,6 +308,12 @@ type AcmCertificateMetadataFilterMemberExported struct { } func (*AcmCertificateMetadataFilterMemberExported) isAcmCertificateMetadataFilter() {} +func (v *AcmCertificateMetadataFilterMemberExported) Serialize(s smithy.ShapeSerializer) { + s.WriteBool(schemas.AcmCertificateMetadataFilter_Exported, v.Value) +} +func (v *AcmCertificateMetadataFilterMemberExported) Deserialize(d smithy.ShapeDeserializer) error { + return d.ReadBool(schemas.AcmCertificateMetadataFilter_Exported, &v.Value) +} // Filter by certificate export option. type AcmCertificateMetadataFilterMemberExportOption struct { @@ -109,6 +323,17 @@ type AcmCertificateMetadataFilterMemberExportOption struct { } func (*AcmCertificateMetadataFilterMemberExportOption) isAcmCertificateMetadataFilter() {} +func (v *AcmCertificateMetadataFilterMemberExportOption) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.AcmCertificateMetadataFilter_ExportOption, string(v.Value)) +} +func (v *AcmCertificateMetadataFilterMemberExportOption) Deserialize(d smithy.ShapeDeserializer) error { + var s string + if err := d.ReadString(schemas.AcmCertificateMetadataFilter_ExportOption, &s); err != nil { + return err + } + v.Value = CertificateExport(s) + return nil +} // Filter by whether the certificate is in use. type AcmCertificateMetadataFilterMemberInUse struct { @@ -118,6 +343,12 @@ type AcmCertificateMetadataFilterMemberInUse struct { } func (*AcmCertificateMetadataFilterMemberInUse) isAcmCertificateMetadataFilter() {} +func (v *AcmCertificateMetadataFilterMemberInUse) Serialize(s smithy.ShapeSerializer) { + s.WriteBool(schemas.AcmCertificateMetadataFilter_InUse, v.Value) +} +func (v *AcmCertificateMetadataFilterMemberInUse) Deserialize(d smithy.ShapeDeserializer) error { + return d.ReadBool(schemas.AcmCertificateMetadataFilter_InUse, &v.Value) +} // Filter by the entity that manages the certificate. type AcmCertificateMetadataFilterMemberManagedBy struct { @@ -127,6 +358,17 @@ type AcmCertificateMetadataFilterMemberManagedBy struct { } func (*AcmCertificateMetadataFilterMemberManagedBy) isAcmCertificateMetadataFilter() {} +func (v *AcmCertificateMetadataFilterMemberManagedBy) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.AcmCertificateMetadataFilter_ManagedBy, string(v.Value)) +} +func (v *AcmCertificateMetadataFilterMemberManagedBy) Deserialize(d smithy.ShapeDeserializer) error { + var s string + if err := d.ReadString(schemas.AcmCertificateMetadataFilter_ManagedBy, &s); err != nil { + return err + } + v.Value = CertificateManagedBy(s) + return nil +} // Filter by certificate renewal status. type AcmCertificateMetadataFilterMemberRenewalStatus struct { @@ -136,6 +378,17 @@ type AcmCertificateMetadataFilterMemberRenewalStatus struct { } func (*AcmCertificateMetadataFilterMemberRenewalStatus) isAcmCertificateMetadataFilter() {} +func (v *AcmCertificateMetadataFilterMemberRenewalStatus) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.AcmCertificateMetadataFilter_RenewalStatus, string(v.Value)) +} +func (v *AcmCertificateMetadataFilterMemberRenewalStatus) Deserialize(d smithy.ShapeDeserializer) error { + var s string + if err := d.ReadString(schemas.AcmCertificateMetadataFilter_RenewalStatus, &s); err != nil { + return err + } + v.Value = RenewalStatus(s) + return nil +} // Filter by certificate status. type AcmCertificateMetadataFilterMemberStatus struct { @@ -145,6 +398,17 @@ type AcmCertificateMetadataFilterMemberStatus struct { } func (*AcmCertificateMetadataFilterMemberStatus) isAcmCertificateMetadataFilter() {} +func (v *AcmCertificateMetadataFilterMemberStatus) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.AcmCertificateMetadataFilter_Status, string(v.Value)) +} +func (v *AcmCertificateMetadataFilterMemberStatus) Deserialize(d smithy.ShapeDeserializer) error { + var s string + if err := d.ReadString(schemas.AcmCertificateMetadataFilter_Status, &s); err != nil { + return err + } + v.Value = CertificateStatus(s) + return nil +} // Filter by certificate type. type AcmCertificateMetadataFilterMemberType struct { @@ -154,6 +418,17 @@ type AcmCertificateMetadataFilterMemberType struct { } func (*AcmCertificateMetadataFilterMemberType) isAcmCertificateMetadataFilter() {} +func (v *AcmCertificateMetadataFilterMemberType) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.AcmCertificateMetadataFilter_Type, string(v.Value)) +} +func (v *AcmCertificateMetadataFilterMemberType) Deserialize(d smithy.ShapeDeserializer) error { + var s string + if err := d.ReadString(schemas.AcmCertificateMetadataFilter_Type, &s); err != nil { + return err + } + v.Value = CertificateType(s) + return nil +} // Filter by validation method. type AcmCertificateMetadataFilterMemberValidationMethod struct { @@ -163,11 +438,858 @@ type AcmCertificateMetadataFilterMemberValidationMethod struct { } func (*AcmCertificateMetadataFilterMemberValidationMethod) isAcmCertificateMetadataFilter() {} +func (v *AcmCertificateMetadataFilterMemberValidationMethod) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.AcmCertificateMetadataFilter_ValidationMethod, string(v.Value)) +} +func (v *AcmCertificateMetadataFilterMemberValidationMethod) Deserialize(d smithy.ShapeDeserializer) error { + var s string + if err := d.ReadString(schemas.AcmCertificateMetadataFilter_ValidationMethod, &s); err != nil { + return err + } + v.Value = ValidationMethod(s) + return nil +} + +// Contains detailed information about an ACME account. +type AcmeAccount struct { + + // The URL of the ACME account. + AccountUrl *string + + // The Amazon Resource Name (ARN) of the external account binding associated with + // this ACME account. + AcmeExternalAccountBindingArn *string + + // The contact information for the ACME account. + Contacts []string + + // The time at which the ACME account was created. + CreatedAt *time.Time + + // The thumbprint of the public key associated with the ACME account. + PublicKeyThumbprint *string + + // The status of the ACME account. + Status AcmeAccountStatus + + noSmithyDocumentSerde +} + +func (v *AcmeAccount) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.AcmeAccount) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *AcmeAccount) SerializeMembers(s smithy.ShapeSerializer) { + if v.AccountUrl != nil { + s.WriteString(schemas.AcmeAccount_AccountUrl, *v.AccountUrl) + } + if v.AcmeExternalAccountBindingArn != nil { + s.WriteString(schemas.AcmeAccount_AcmeExternalAccountBindingArn, *v.AcmeExternalAccountBindingArn) + } + serializeContactList(s, schemas.AcmeAccount_Contacts, v.Contacts) + if v.CreatedAt != nil { + s.WriteTime(schemas.AcmeAccount_CreatedAt, *v.CreatedAt) + } + if v.PublicKeyThumbprint != nil { + s.WriteString(schemas.AcmeAccount_PublicKeyThumbprint, *v.PublicKeyThumbprint) + } + if v.Status != "" { + s.WriteString(schemas.AcmeAccount_Status, string(v.Status)) + } +} +func (v *AcmeAccount) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.AcmeAccount, func(s *smithy.Schema) error { + switch s { + case schemas.AcmeAccount_AccountUrl: + v.AccountUrl = new(string) + return d.ReadString(schemas.AcmeAccount_AccountUrl, v.AccountUrl) + case schemas.AcmeAccount_AcmeExternalAccountBindingArn: + v.AcmeExternalAccountBindingArn = new(string) + return d.ReadString(schemas.AcmeAccount_AcmeExternalAccountBindingArn, v.AcmeExternalAccountBindingArn) + case schemas.AcmeAccount_Contacts: + return deserializeContactList(d, schemas.AcmeAccount_Contacts, &v.Contacts) + case schemas.AcmeAccount_CreatedAt: + v.CreatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeAccount_CreatedAt, v.CreatedAt) + case schemas.AcmeAccount_PublicKeyThumbprint: + v.PublicKeyThumbprint = new(string) + return d.ReadString(schemas.AcmeAccount_PublicKeyThumbprint, v.PublicKeyThumbprint) + case schemas.AcmeAccount_Status: + var ev string + if err := d.ReadString(schemas.AcmeAccount_Status, &ev); err != nil { + return err + } + v.Status = AcmeAccountStatus(ev) + return nil + } + return nil + }) +} + +// Contains summary information about an ACME account. +type AcmeAccountSummary struct { + + // The URL of the ACME account. + AccountUrl *string + + // The Amazon Resource Name (ARN) of the external account binding associated with + // this ACME account. + AcmeExternalAccountBindingArn *string + + // The contact information for the ACME account. + Contacts []string + + // The time at which the ACME account was created. + CreatedAt *time.Time + + // The thumbprint of the public key associated with the ACME account. + PublicKeyThumbprint *string + + // The status of the ACME account. + Status AcmeAccountStatus + + noSmithyDocumentSerde +} + +func (v *AcmeAccountSummary) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.AcmeAccountSummary) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *AcmeAccountSummary) SerializeMembers(s smithy.ShapeSerializer) { + if v.AccountUrl != nil { + s.WriteString(schemas.AcmeAccountSummary_AccountUrl, *v.AccountUrl) + } + if v.AcmeExternalAccountBindingArn != nil { + s.WriteString(schemas.AcmeAccountSummary_AcmeExternalAccountBindingArn, *v.AcmeExternalAccountBindingArn) + } + serializeContactList(s, schemas.AcmeAccountSummary_Contacts, v.Contacts) + if v.CreatedAt != nil { + s.WriteTime(schemas.AcmeAccountSummary_CreatedAt, *v.CreatedAt) + } + if v.PublicKeyThumbprint != nil { + s.WriteString(schemas.AcmeAccountSummary_PublicKeyThumbprint, *v.PublicKeyThumbprint) + } + if v.Status != "" { + s.WriteString(schemas.AcmeAccountSummary_Status, string(v.Status)) + } +} +func (v *AcmeAccountSummary) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.AcmeAccountSummary, func(s *smithy.Schema) error { + switch s { + case schemas.AcmeAccountSummary_AccountUrl: + v.AccountUrl = new(string) + return d.ReadString(schemas.AcmeAccountSummary_AccountUrl, v.AccountUrl) + case schemas.AcmeAccountSummary_AcmeExternalAccountBindingArn: + v.AcmeExternalAccountBindingArn = new(string) + return d.ReadString(schemas.AcmeAccountSummary_AcmeExternalAccountBindingArn, v.AcmeExternalAccountBindingArn) + case schemas.AcmeAccountSummary_Contacts: + return deserializeContactList(d, schemas.AcmeAccountSummary_Contacts, &v.Contacts) + case schemas.AcmeAccountSummary_CreatedAt: + v.CreatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeAccountSummary_CreatedAt, v.CreatedAt) + case schemas.AcmeAccountSummary_PublicKeyThumbprint: + v.PublicKeyThumbprint = new(string) + return d.ReadString(schemas.AcmeAccountSummary_PublicKeyThumbprint, v.PublicKeyThumbprint) + case schemas.AcmeAccountSummary_Status: + var ev string + if err := d.ReadString(schemas.AcmeAccountSummary_Status, &ev); err != nil { + return err + } + v.Status = AcmeAccountStatus(ev) + return nil + } + return nil + }) +} + +// Contains detailed information about an ACME domain validation. +type AcmeDomainValidation struct { + + // The Amazon Resource Name (ARN) of the ACME domain validation. + AcmeDomainValidationArn *string + + // The Amazon Resource Name (ARN) of the ACME endpoint. + AcmeEndpointArn *string + + // The time at which the domain validation was created. + CreatedAt *time.Time + + // The domain name being validated. + DomainName *string + + // Details about the failure, if the validation failed. + FailureDetails *FailureDetails + + // Details about the prevalidation configuration. + PrevalidationDetails PrevalidationDetails + + // The type of prevalidation used. + PrevalidationType PrevalidationType + + // The status of the domain validation. + Status AcmeDomainValidationStatus + + // The time at which the domain validation was last updated. + UpdatedAt *time.Time + + noSmithyDocumentSerde +} + +func (v *AcmeDomainValidation) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.AcmeDomainValidation) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *AcmeDomainValidation) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeDomainValidationArn != nil { + s.WriteString(schemas.AcmeDomainValidation_AcmeDomainValidationArn, *v.AcmeDomainValidationArn) + } + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.AcmeDomainValidation_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.CreatedAt != nil { + s.WriteTime(schemas.AcmeDomainValidation_CreatedAt, *v.CreatedAt) + } + if v.DomainName != nil { + s.WriteString(schemas.AcmeDomainValidation_DomainName, *v.DomainName) + } + if v.FailureDetails != nil { + s.WriteStruct(schemas.AcmeDomainValidation_FailureDetails) + v.FailureDetails.SerializeMembers(s) + s.CloseStruct() + } + serializePrevalidationDetails(s, schemas.AcmeDomainValidation_PrevalidationDetails, v.PrevalidationDetails) + if v.PrevalidationType != "" { + s.WriteString(schemas.AcmeDomainValidation_PrevalidationType, string(v.PrevalidationType)) + } + if v.Status != "" { + s.WriteString(schemas.AcmeDomainValidation_Status, string(v.Status)) + } + if v.UpdatedAt != nil { + s.WriteTime(schemas.AcmeDomainValidation_UpdatedAt, *v.UpdatedAt) + } +} +func (v *AcmeDomainValidation) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.AcmeDomainValidation, func(s *smithy.Schema) error { + switch s { + case schemas.AcmeDomainValidation_AcmeDomainValidationArn: + v.AcmeDomainValidationArn = new(string) + return d.ReadString(schemas.AcmeDomainValidation_AcmeDomainValidationArn, v.AcmeDomainValidationArn) + case schemas.AcmeDomainValidation_AcmeEndpointArn: + v.AcmeEndpointArn = new(string) + return d.ReadString(schemas.AcmeDomainValidation_AcmeEndpointArn, v.AcmeEndpointArn) + case schemas.AcmeDomainValidation_CreatedAt: + v.CreatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeDomainValidation_CreatedAt, v.CreatedAt) + case schemas.AcmeDomainValidation_DomainName: + v.DomainName = new(string) + return d.ReadString(schemas.AcmeDomainValidation_DomainName, v.DomainName) + case schemas.AcmeDomainValidation_FailureDetails: + v.FailureDetails = &FailureDetails{} + return v.FailureDetails.Deserialize(d) + case schemas.AcmeDomainValidation_PrevalidationDetails: + return deserializePrevalidationDetails(d, schemas.AcmeDomainValidation_PrevalidationDetails, &v.PrevalidationDetails) + case schemas.AcmeDomainValidation_PrevalidationType: + var ev string + if err := d.ReadString(schemas.AcmeDomainValidation_PrevalidationType, &ev); err != nil { + return err + } + v.PrevalidationType = PrevalidationType(ev) + return nil + case schemas.AcmeDomainValidation_Status: + var ev string + if err := d.ReadString(schemas.AcmeDomainValidation_Status, &ev); err != nil { + return err + } + v.Status = AcmeDomainValidationStatus(ev) + return nil + case schemas.AcmeDomainValidation_UpdatedAt: + v.UpdatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeDomainValidation_UpdatedAt, v.UpdatedAt) + } + return nil + }) +} + +// Contains summary information about an ACME domain validation. +type AcmeDomainValidationSummary struct { + + // The Amazon Resource Name (ARN) of the ACME domain validation. + AcmeDomainValidationArn *string + + // The Amazon Resource Name (ARN) of the ACME endpoint. + AcmeEndpointArn *string + + // The time at which the domain validation was created. + CreatedAt *time.Time + + // The domain name being validated. + DomainName *string + + // Details about the failure, if the validation failed. + FailureDetails *FailureDetails + + // Details about the prevalidation configuration. + PrevalidationDetails PrevalidationDetails + + // The type of prevalidation used. + PrevalidationType PrevalidationType + + // The status of the domain validation. + Status AcmeDomainValidationStatus + + // The time at which the domain validation was last updated. + UpdatedAt *time.Time + + noSmithyDocumentSerde +} + +func (v *AcmeDomainValidationSummary) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.AcmeDomainValidationSummary) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *AcmeDomainValidationSummary) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeDomainValidationArn != nil { + s.WriteString(schemas.AcmeDomainValidationSummary_AcmeDomainValidationArn, *v.AcmeDomainValidationArn) + } + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.AcmeDomainValidationSummary_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.CreatedAt != nil { + s.WriteTime(schemas.AcmeDomainValidationSummary_CreatedAt, *v.CreatedAt) + } + if v.DomainName != nil { + s.WriteString(schemas.AcmeDomainValidationSummary_DomainName, *v.DomainName) + } + if v.FailureDetails != nil { + s.WriteStruct(schemas.AcmeDomainValidationSummary_FailureDetails) + v.FailureDetails.SerializeMembers(s) + s.CloseStruct() + } + serializePrevalidationDetails(s, schemas.AcmeDomainValidationSummary_PrevalidationDetails, v.PrevalidationDetails) + if v.PrevalidationType != "" { + s.WriteString(schemas.AcmeDomainValidationSummary_PrevalidationType, string(v.PrevalidationType)) + } + if v.Status != "" { + s.WriteString(schemas.AcmeDomainValidationSummary_Status, string(v.Status)) + } + if v.UpdatedAt != nil { + s.WriteTime(schemas.AcmeDomainValidationSummary_UpdatedAt, *v.UpdatedAt) + } +} +func (v *AcmeDomainValidationSummary) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.AcmeDomainValidationSummary, func(s *smithy.Schema) error { + switch s { + case schemas.AcmeDomainValidationSummary_AcmeDomainValidationArn: + v.AcmeDomainValidationArn = new(string) + return d.ReadString(schemas.AcmeDomainValidationSummary_AcmeDomainValidationArn, v.AcmeDomainValidationArn) + case schemas.AcmeDomainValidationSummary_AcmeEndpointArn: + v.AcmeEndpointArn = new(string) + return d.ReadString(schemas.AcmeDomainValidationSummary_AcmeEndpointArn, v.AcmeEndpointArn) + case schemas.AcmeDomainValidationSummary_CreatedAt: + v.CreatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeDomainValidationSummary_CreatedAt, v.CreatedAt) + case schemas.AcmeDomainValidationSummary_DomainName: + v.DomainName = new(string) + return d.ReadString(schemas.AcmeDomainValidationSummary_DomainName, v.DomainName) + case schemas.AcmeDomainValidationSummary_FailureDetails: + v.FailureDetails = &FailureDetails{} + return v.FailureDetails.Deserialize(d) + case schemas.AcmeDomainValidationSummary_PrevalidationDetails: + return deserializePrevalidationDetails(d, schemas.AcmeDomainValidationSummary_PrevalidationDetails, &v.PrevalidationDetails) + case schemas.AcmeDomainValidationSummary_PrevalidationType: + var ev string + if err := d.ReadString(schemas.AcmeDomainValidationSummary_PrevalidationType, &ev); err != nil { + return err + } + v.PrevalidationType = PrevalidationType(ev) + return nil + case schemas.AcmeDomainValidationSummary_Status: + var ev string + if err := d.ReadString(schemas.AcmeDomainValidationSummary_Status, &ev); err != nil { + return err + } + v.Status = AcmeDomainValidationStatus(ev) + return nil + case schemas.AcmeDomainValidationSummary_UpdatedAt: + v.UpdatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeDomainValidationSummary_UpdatedAt, v.UpdatedAt) + } + return nil + }) +} + +// Contains detailed information about an ACME endpoint. +type AcmeEndpoint struct { + + // The Amazon Resource Name (ARN) of the ACME endpoint. + AcmeEndpointArn *string + + // The authorization behavior of the ACME endpoint. + AuthorizationBehavior AcmeAuthorizationBehavior + + // The certificate authority configuration for the ACME endpoint. + CertificateAuthority CertificateAuthority + + // Tags applied to certificates issued through this ACME endpoint. + CertificateTags []Tag + + // Whether ACME clients must provide contact information during account + // registration. + Contact AcmeContact + + // The time at which the ACME endpoint was created. + CreatedAt *time.Time + + // The URL of the ACME endpoint. + EndpointUrl *string + + // The reason the ACME endpoint failed, if applicable. + FailureReason *string + + // The status of the ACME endpoint. + Status AcmeEndpointStatus + + // The time at which the ACME endpoint was last updated. + UpdatedAt *time.Time + + noSmithyDocumentSerde +} + +func (v *AcmeEndpoint) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.AcmeEndpoint) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *AcmeEndpoint) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.AcmeEndpoint_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.AuthorizationBehavior != "" { + s.WriteString(schemas.AcmeEndpoint_AuthorizationBehavior, string(v.AuthorizationBehavior)) + } + serializeCertificateAuthority(s, schemas.AcmeEndpoint_CertificateAuthority, v.CertificateAuthority) + serializeTagList(s, schemas.AcmeEndpoint_CertificateTags, v.CertificateTags) + if v.Contact != "" { + s.WriteString(schemas.AcmeEndpoint_Contact, string(v.Contact)) + } + if v.CreatedAt != nil { + s.WriteTime(schemas.AcmeEndpoint_CreatedAt, *v.CreatedAt) + } + if v.EndpointUrl != nil { + s.WriteString(schemas.AcmeEndpoint_EndpointUrl, *v.EndpointUrl) + } + if v.FailureReason != nil { + s.WriteString(schemas.AcmeEndpoint_FailureReason, *v.FailureReason) + } + if v.Status != "" { + s.WriteString(schemas.AcmeEndpoint_Status, string(v.Status)) + } + if v.UpdatedAt != nil { + s.WriteTime(schemas.AcmeEndpoint_UpdatedAt, *v.UpdatedAt) + } +} +func (v *AcmeEndpoint) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.AcmeEndpoint, func(s *smithy.Schema) error { + switch s { + case schemas.AcmeEndpoint_AcmeEndpointArn: + v.AcmeEndpointArn = new(string) + return d.ReadString(schemas.AcmeEndpoint_AcmeEndpointArn, v.AcmeEndpointArn) + case schemas.AcmeEndpoint_AuthorizationBehavior: + var ev string + if err := d.ReadString(schemas.AcmeEndpoint_AuthorizationBehavior, &ev); err != nil { + return err + } + v.AuthorizationBehavior = AcmeAuthorizationBehavior(ev) + return nil + case schemas.AcmeEndpoint_CertificateAuthority: + return deserializeCertificateAuthority(d, schemas.AcmeEndpoint_CertificateAuthority, &v.CertificateAuthority) + case schemas.AcmeEndpoint_CertificateTags: + return deserializeTagList(d, schemas.AcmeEndpoint_CertificateTags, &v.CertificateTags) + case schemas.AcmeEndpoint_Contact: + var ev string + if err := d.ReadString(schemas.AcmeEndpoint_Contact, &ev); err != nil { + return err + } + v.Contact = AcmeContact(ev) + return nil + case schemas.AcmeEndpoint_CreatedAt: + v.CreatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeEndpoint_CreatedAt, v.CreatedAt) + case schemas.AcmeEndpoint_EndpointUrl: + v.EndpointUrl = new(string) + return d.ReadString(schemas.AcmeEndpoint_EndpointUrl, v.EndpointUrl) + case schemas.AcmeEndpoint_FailureReason: + v.FailureReason = new(string) + return d.ReadString(schemas.AcmeEndpoint_FailureReason, v.FailureReason) + case schemas.AcmeEndpoint_Status: + var ev string + if err := d.ReadString(schemas.AcmeEndpoint_Status, &ev); err != nil { + return err + } + v.Status = AcmeEndpointStatus(ev) + return nil + case schemas.AcmeEndpoint_UpdatedAt: + v.UpdatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeEndpoint_UpdatedAt, v.UpdatedAt) + } + return nil + }) +} + +// Contains summary information about an ACME endpoint. +type AcmeEndpointSummary struct { + + // The Amazon Resource Name (ARN) of the ACME endpoint. + AcmeEndpointArn *string + + // The authorization behavior of the ACME endpoint. + AuthorizationBehavior AcmeAuthorizationBehavior + + // The certificate authority configuration for the ACME endpoint. + CertificateAuthority CertificateAuthority + + // Tags applied to certificates issued through this ACME endpoint. + CertificateTags []Tag + + // Whether ACME clients must provide contact information during account + // registration. + Contact AcmeContact + + // The time at which the ACME endpoint was created. + CreatedAt *time.Time + + // The URL of the ACME endpoint. + EndpointUrl *string + + // The reason the ACME endpoint failed, if applicable. + FailureReason *string + + // The status of the ACME endpoint. + Status AcmeEndpointStatus + + // The time at which the ACME endpoint was last updated. + UpdatedAt *time.Time + + noSmithyDocumentSerde +} + +func (v *AcmeEndpointSummary) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.AcmeEndpointSummary) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *AcmeEndpointSummary) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.AcmeEndpointSummary_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.AuthorizationBehavior != "" { + s.WriteString(schemas.AcmeEndpointSummary_AuthorizationBehavior, string(v.AuthorizationBehavior)) + } + serializeCertificateAuthority(s, schemas.AcmeEndpointSummary_CertificateAuthority, v.CertificateAuthority) + serializeTagList(s, schemas.AcmeEndpointSummary_CertificateTags, v.CertificateTags) + if v.Contact != "" { + s.WriteString(schemas.AcmeEndpointSummary_Contact, string(v.Contact)) + } + if v.CreatedAt != nil { + s.WriteTime(schemas.AcmeEndpointSummary_CreatedAt, *v.CreatedAt) + } + if v.EndpointUrl != nil { + s.WriteString(schemas.AcmeEndpointSummary_EndpointUrl, *v.EndpointUrl) + } + if v.FailureReason != nil { + s.WriteString(schemas.AcmeEndpointSummary_FailureReason, *v.FailureReason) + } + if v.Status != "" { + s.WriteString(schemas.AcmeEndpointSummary_Status, string(v.Status)) + } + if v.UpdatedAt != nil { + s.WriteTime(schemas.AcmeEndpointSummary_UpdatedAt, *v.UpdatedAt) + } +} +func (v *AcmeEndpointSummary) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.AcmeEndpointSummary, func(s *smithy.Schema) error { + switch s { + case schemas.AcmeEndpointSummary_AcmeEndpointArn: + v.AcmeEndpointArn = new(string) + return d.ReadString(schemas.AcmeEndpointSummary_AcmeEndpointArn, v.AcmeEndpointArn) + case schemas.AcmeEndpointSummary_AuthorizationBehavior: + var ev string + if err := d.ReadString(schemas.AcmeEndpointSummary_AuthorizationBehavior, &ev); err != nil { + return err + } + v.AuthorizationBehavior = AcmeAuthorizationBehavior(ev) + return nil + case schemas.AcmeEndpointSummary_CertificateAuthority: + return deserializeCertificateAuthority(d, schemas.AcmeEndpointSummary_CertificateAuthority, &v.CertificateAuthority) + case schemas.AcmeEndpointSummary_CertificateTags: + return deserializeTagList(d, schemas.AcmeEndpointSummary_CertificateTags, &v.CertificateTags) + case schemas.AcmeEndpointSummary_Contact: + var ev string + if err := d.ReadString(schemas.AcmeEndpointSummary_Contact, &ev); err != nil { + return err + } + v.Contact = AcmeContact(ev) + return nil + case schemas.AcmeEndpointSummary_CreatedAt: + v.CreatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeEndpointSummary_CreatedAt, v.CreatedAt) + case schemas.AcmeEndpointSummary_EndpointUrl: + v.EndpointUrl = new(string) + return d.ReadString(schemas.AcmeEndpointSummary_EndpointUrl, v.EndpointUrl) + case schemas.AcmeEndpointSummary_FailureReason: + v.FailureReason = new(string) + return d.ReadString(schemas.AcmeEndpointSummary_FailureReason, v.FailureReason) + case schemas.AcmeEndpointSummary_Status: + var ev string + if err := d.ReadString(schemas.AcmeEndpointSummary_Status, &ev); err != nil { + return err + } + v.Status = AcmeEndpointStatus(ev) + return nil + case schemas.AcmeEndpointSummary_UpdatedAt: + v.UpdatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeEndpointSummary_UpdatedAt, v.UpdatedAt) + } + return nil + }) +} + +// Contains detailed information about an ACME external account binding. +type AcmeExternalAccountBinding struct { + + // The Amazon Resource Name (ARN) of the ACME endpoint. + AcmeEndpointArn *string + + // The Amazon Resource Name (ARN) of the ACME external account binding. + AcmeExternalAccountBindingArn *string + + // The time at which the external account binding was created. + CreatedAt *time.Time + + // The time at which the external account binding expires. + ExpiresAt *time.Time + + // The time at which the external account binding was last used. + LastUsedAt *time.Time + + // The time at which the external account binding was revoked. + RevokedAt *time.Time + + // The Amazon Resource Name (ARN) of the IAM role associated with the external + // account binding. + RoleArn *string + + // The time at which the external account binding was last updated. + UpdatedAt *time.Time + + noSmithyDocumentSerde +} + +func (v *AcmeExternalAccountBinding) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.AcmeExternalAccountBinding) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *AcmeExternalAccountBinding) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.AcmeExternalAccountBinding_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.AcmeExternalAccountBindingArn != nil { + s.WriteString(schemas.AcmeExternalAccountBinding_AcmeExternalAccountBindingArn, *v.AcmeExternalAccountBindingArn) + } + if v.CreatedAt != nil { + s.WriteTime(schemas.AcmeExternalAccountBinding_CreatedAt, *v.CreatedAt) + } + if v.ExpiresAt != nil { + s.WriteTime(schemas.AcmeExternalAccountBinding_ExpiresAt, *v.ExpiresAt) + } + if v.LastUsedAt != nil { + s.WriteTime(schemas.AcmeExternalAccountBinding_LastUsedAt, *v.LastUsedAt) + } + if v.RevokedAt != nil { + s.WriteTime(schemas.AcmeExternalAccountBinding_RevokedAt, *v.RevokedAt) + } + if v.RoleArn != nil { + s.WriteString(schemas.AcmeExternalAccountBinding_RoleArn, *v.RoleArn) + } + if v.UpdatedAt != nil { + s.WriteTime(schemas.AcmeExternalAccountBinding_UpdatedAt, *v.UpdatedAt) + } +} +func (v *AcmeExternalAccountBinding) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.AcmeExternalAccountBinding, func(s *smithy.Schema) error { + switch s { + case schemas.AcmeExternalAccountBinding_AcmeEndpointArn: + v.AcmeEndpointArn = new(string) + return d.ReadString(schemas.AcmeExternalAccountBinding_AcmeEndpointArn, v.AcmeEndpointArn) + case schemas.AcmeExternalAccountBinding_AcmeExternalAccountBindingArn: + v.AcmeExternalAccountBindingArn = new(string) + return d.ReadString(schemas.AcmeExternalAccountBinding_AcmeExternalAccountBindingArn, v.AcmeExternalAccountBindingArn) + case schemas.AcmeExternalAccountBinding_CreatedAt: + v.CreatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeExternalAccountBinding_CreatedAt, v.CreatedAt) + case schemas.AcmeExternalAccountBinding_ExpiresAt: + v.ExpiresAt = new(time.Time) + return d.ReadTime(schemas.AcmeExternalAccountBinding_ExpiresAt, v.ExpiresAt) + case schemas.AcmeExternalAccountBinding_LastUsedAt: + v.LastUsedAt = new(time.Time) + return d.ReadTime(schemas.AcmeExternalAccountBinding_LastUsedAt, v.LastUsedAt) + case schemas.AcmeExternalAccountBinding_RevokedAt: + v.RevokedAt = new(time.Time) + return d.ReadTime(schemas.AcmeExternalAccountBinding_RevokedAt, v.RevokedAt) + case schemas.AcmeExternalAccountBinding_RoleArn: + v.RoleArn = new(string) + return d.ReadString(schemas.AcmeExternalAccountBinding_RoleArn, v.RoleArn) + case schemas.AcmeExternalAccountBinding_UpdatedAt: + v.UpdatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeExternalAccountBinding_UpdatedAt, v.UpdatedAt) + } + return nil + }) +} + +// Contains summary information about an ACME external account binding. +type AcmeExternalAccountBindingSummary struct { + + // The Amazon Resource Name (ARN) of the ACME endpoint. + AcmeEndpointArn *string + + // The Amazon Resource Name (ARN) of the ACME external account binding. + AcmeExternalAccountBindingArn *string + + // The time at which the external account binding was created. + CreatedAt *time.Time + + // The time at which the external account binding expires. + ExpiresAt *time.Time + + // The time at which the external account binding was last used. + LastUsedAt *time.Time + + // The time at which the external account binding was revoked. + RevokedAt *time.Time + + // The Amazon Resource Name (ARN) of the IAM role associated with the external + // account binding. + RoleArn *string + + // The time at which the external account binding was last updated. + UpdatedAt *time.Time + + noSmithyDocumentSerde +} + +func (v *AcmeExternalAccountBindingSummary) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.AcmeExternalAccountBindingSummary) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *AcmeExternalAccountBindingSummary) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.AcmeExternalAccountBindingSummary_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.AcmeExternalAccountBindingArn != nil { + s.WriteString(schemas.AcmeExternalAccountBindingSummary_AcmeExternalAccountBindingArn, *v.AcmeExternalAccountBindingArn) + } + if v.CreatedAt != nil { + s.WriteTime(schemas.AcmeExternalAccountBindingSummary_CreatedAt, *v.CreatedAt) + } + if v.ExpiresAt != nil { + s.WriteTime(schemas.AcmeExternalAccountBindingSummary_ExpiresAt, *v.ExpiresAt) + } + if v.LastUsedAt != nil { + s.WriteTime(schemas.AcmeExternalAccountBindingSummary_LastUsedAt, *v.LastUsedAt) + } + if v.RevokedAt != nil { + s.WriteTime(schemas.AcmeExternalAccountBindingSummary_RevokedAt, *v.RevokedAt) + } + if v.RoleArn != nil { + s.WriteString(schemas.AcmeExternalAccountBindingSummary_RoleArn, *v.RoleArn) + } + if v.UpdatedAt != nil { + s.WriteTime(schemas.AcmeExternalAccountBindingSummary_UpdatedAt, *v.UpdatedAt) + } +} +func (v *AcmeExternalAccountBindingSummary) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.AcmeExternalAccountBindingSummary, func(s *smithy.Schema) error { + switch s { + case schemas.AcmeExternalAccountBindingSummary_AcmeEndpointArn: + v.AcmeEndpointArn = new(string) + return d.ReadString(schemas.AcmeExternalAccountBindingSummary_AcmeEndpointArn, v.AcmeEndpointArn) + case schemas.AcmeExternalAccountBindingSummary_AcmeExternalAccountBindingArn: + v.AcmeExternalAccountBindingArn = new(string) + return d.ReadString(schemas.AcmeExternalAccountBindingSummary_AcmeExternalAccountBindingArn, v.AcmeExternalAccountBindingArn) + case schemas.AcmeExternalAccountBindingSummary_CreatedAt: + v.CreatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeExternalAccountBindingSummary_CreatedAt, v.CreatedAt) + case schemas.AcmeExternalAccountBindingSummary_ExpiresAt: + v.ExpiresAt = new(time.Time) + return d.ReadTime(schemas.AcmeExternalAccountBindingSummary_ExpiresAt, v.ExpiresAt) + case schemas.AcmeExternalAccountBindingSummary_LastUsedAt: + v.LastUsedAt = new(time.Time) + return d.ReadTime(schemas.AcmeExternalAccountBindingSummary_LastUsedAt, v.LastUsedAt) + case schemas.AcmeExternalAccountBindingSummary_RevokedAt: + v.RevokedAt = new(time.Time) + return d.ReadTime(schemas.AcmeExternalAccountBindingSummary_RevokedAt, v.RevokedAt) + case schemas.AcmeExternalAccountBindingSummary_RoleArn: + v.RoleArn = new(string) + return d.ReadString(schemas.AcmeExternalAccountBindingSummary_RoleArn, v.RoleArn) + case schemas.AcmeExternalAccountBindingSummary_UpdatedAt: + v.UpdatedAt = new(time.Time) + return d.ReadTime(schemas.AcmeExternalAccountBindingSummary_UpdatedAt, v.UpdatedAt) + } + return nil + }) +} + +// Defines the certificate authority to use for an ACME endpoint. +// +// The following types satisfy this interface: +// +// CertificateAuthorityMemberPublicCertificateAuthority +type CertificateAuthority interface { + isCertificateAuthority() +} + +// Configuration for using a public certificate authority. +type CertificateAuthorityMemberPublicCertificateAuthority struct { + Value PublicCertificateAuthority + + noSmithyDocumentSerde +} + +func (*CertificateAuthorityMemberPublicCertificateAuthority) isCertificateAuthority() {} +func (v *CertificateAuthorityMemberPublicCertificateAuthority) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CertificateAuthority_PublicCertificateAuthority) + v.Value.SerializeMembers(s) + s.CloseStruct() +} +func (v *CertificateAuthorityMemberPublicCertificateAuthority) Deserialize(d smithy.ShapeDeserializer) error { + return v.Value.Deserialize(d) +} // Contains metadata about an ACM certificate. This structure is returned in the // response to a DescribeCertificaterequest. type CertificateDetail struct { + // The ACME account identifier associated with the certificate. + AcmeAccountId *string + + // The ARN of the ACME endpoint used to issue the certificate. + AcmeEndpointArn *string + // The Amazon Resource Name (ARN) of the certificate. For more information about // ARNs, see [Amazon Resource Names (ARNs)]in the Amazon Web Services General Reference. // @@ -180,6 +1302,9 @@ type CertificateDetail struct { // arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012 CertificateAuthorityArn *string + // The origin of the certificate's key pair. + CertificateKeyPairOrigin CertificateKeyPairOrigin + // The time at which the certificate was requested. CreatedAt *time.Time @@ -239,11 +1364,9 @@ type CertificateDetail struct { // The time before which the certificate is not valid. NotBefore *time.Time - // Value that specifies whether to add the certificate to a transparency log. - // Certificate transparency makes it possible to detect SSL certificates that have - // been mistakenly or maliciously issued. A browser might respond to certificate - // that has not been logged by showing an error message. The logs are - // cryptographically secure. + // Contains the certificate options. Certificate transparency logging opt-out is + // no longer available. All public certificates are recorded in a certificate + // transparency log. Options *CertificateOptions // Specifies whether the certificate is eligible for renewal. At this time, only @@ -305,9 +1428,239 @@ type CertificateDetail struct { // [managed renewal]: https://docs.aws.amazon.com/acm/latest/userguide/acm-renewal.html Type CertificateType + // Contains information about the most recent update to the certificate. This + // field exists only when the certificate type is AMAZON_ISSUED and a certificate + // update has been requested. + UpdateSummary *UpdateSummary + noSmithyDocumentSerde } +func (v *CertificateDetail) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CertificateDetail) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CertificateDetail) SerializeMembers(s smithy.ShapeSerializer) { + if v.AcmeAccountId != nil { + s.WriteString(schemas.CertificateDetail_AcmeAccountId, *v.AcmeAccountId) + } + if v.AcmeEndpointArn != nil { + s.WriteString(schemas.CertificateDetail_AcmeEndpointArn, *v.AcmeEndpointArn) + } + if v.CertificateArn != nil { + s.WriteString(schemas.CertificateDetail_CertificateArn, *v.CertificateArn) + } + if v.CertificateAuthorityArn != nil { + s.WriteString(schemas.CertificateDetail_CertificateAuthorityArn, *v.CertificateAuthorityArn) + } + if v.CertificateKeyPairOrigin != "" { + s.WriteString(schemas.CertificateDetail_CertificateKeyPairOrigin, string(v.CertificateKeyPairOrigin)) + } + if v.CreatedAt != nil { + s.WriteTime(schemas.CertificateDetail_CreatedAt, *v.CreatedAt) + } + if v.DomainName != nil { + s.WriteString(schemas.CertificateDetail_DomainName, *v.DomainName) + } + serializeDomainValidationList(s, schemas.CertificateDetail_DomainValidationOptions, v.DomainValidationOptions) + serializeExtendedKeyUsageList(s, schemas.CertificateDetail_ExtendedKeyUsages, v.ExtendedKeyUsages) + if v.FailureReason != "" { + s.WriteString(schemas.CertificateDetail_FailureReason, string(v.FailureReason)) + } + if v.ImportedAt != nil { + s.WriteTime(schemas.CertificateDetail_ImportedAt, *v.ImportedAt) + } + serializeInUseList(s, schemas.CertificateDetail_InUseBy, v.InUseBy) + if v.IssuedAt != nil { + s.WriteTime(schemas.CertificateDetail_IssuedAt, *v.IssuedAt) + } + if v.Issuer != nil { + s.WriteString(schemas.CertificateDetail_Issuer, *v.Issuer) + } + if v.KeyAlgorithm != "" { + s.WriteString(schemas.CertificateDetail_KeyAlgorithm, string(v.KeyAlgorithm)) + } + serializeKeyUsageList(s, schemas.CertificateDetail_KeyUsages, v.KeyUsages) + if v.ManagedBy != "" { + s.WriteString(schemas.CertificateDetail_ManagedBy, string(v.ManagedBy)) + } + if v.NotAfter != nil { + s.WriteTime(schemas.CertificateDetail_NotAfter, *v.NotAfter) + } + if v.NotBefore != nil { + s.WriteTime(schemas.CertificateDetail_NotBefore, *v.NotBefore) + } + if v.Options != nil { + s.WriteStruct(schemas.CertificateDetail_Options) + v.Options.SerializeMembers(s) + s.CloseStruct() + } + if v.RenewalEligibility != "" { + s.WriteString(schemas.CertificateDetail_RenewalEligibility, string(v.RenewalEligibility)) + } + if v.RenewalSummary != nil { + s.WriteStruct(schemas.CertificateDetail_RenewalSummary) + v.RenewalSummary.SerializeMembers(s) + s.CloseStruct() + } + if v.RevocationReason != "" { + s.WriteString(schemas.CertificateDetail_RevocationReason, string(v.RevocationReason)) + } + if v.RevokedAt != nil { + s.WriteTime(schemas.CertificateDetail_RevokedAt, *v.RevokedAt) + } + if v.Serial != nil { + s.WriteString(schemas.CertificateDetail_Serial, *v.Serial) + } + if v.SignatureAlgorithm != nil { + s.WriteString(schemas.CertificateDetail_SignatureAlgorithm, *v.SignatureAlgorithm) + } + if v.Status != "" { + s.WriteString(schemas.CertificateDetail_Status, string(v.Status)) + } + if v.Subject != nil { + s.WriteString(schemas.CertificateDetail_Subject, *v.Subject) + } + serializeDomainList(s, schemas.CertificateDetail_SubjectAlternativeNames, v.SubjectAlternativeNames) + if v.Type != "" { + s.WriteString(schemas.CertificateDetail_Type, string(v.Type)) + } + if v.UpdateSummary != nil { + s.WriteStruct(schemas.CertificateDetail_UpdateSummary) + v.UpdateSummary.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *CertificateDetail) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.CertificateDetail, func(s *smithy.Schema) error { + switch s { + case schemas.CertificateDetail_AcmeAccountId: + v.AcmeAccountId = new(string) + return d.ReadString(schemas.CertificateDetail_AcmeAccountId, v.AcmeAccountId) + case schemas.CertificateDetail_AcmeEndpointArn: + v.AcmeEndpointArn = new(string) + return d.ReadString(schemas.CertificateDetail_AcmeEndpointArn, v.AcmeEndpointArn) + case schemas.CertificateDetail_CertificateArn: + v.CertificateArn = new(string) + return d.ReadString(schemas.CertificateDetail_CertificateArn, v.CertificateArn) + case schemas.CertificateDetail_CertificateAuthorityArn: + v.CertificateAuthorityArn = new(string) + return d.ReadString(schemas.CertificateDetail_CertificateAuthorityArn, v.CertificateAuthorityArn) + case schemas.CertificateDetail_CertificateKeyPairOrigin: + var ev string + if err := d.ReadString(schemas.CertificateDetail_CertificateKeyPairOrigin, &ev); err != nil { + return err + } + v.CertificateKeyPairOrigin = CertificateKeyPairOrigin(ev) + return nil + case schemas.CertificateDetail_CreatedAt: + v.CreatedAt = new(time.Time) + return d.ReadTime(schemas.CertificateDetail_CreatedAt, v.CreatedAt) + case schemas.CertificateDetail_DomainName: + v.DomainName = new(string) + return d.ReadString(schemas.CertificateDetail_DomainName, v.DomainName) + case schemas.CertificateDetail_DomainValidationOptions: + return deserializeDomainValidationList(d, schemas.CertificateDetail_DomainValidationOptions, &v.DomainValidationOptions) + case schemas.CertificateDetail_ExtendedKeyUsages: + return deserializeExtendedKeyUsageList(d, schemas.CertificateDetail_ExtendedKeyUsages, &v.ExtendedKeyUsages) + case schemas.CertificateDetail_FailureReason: + var ev string + if err := d.ReadString(schemas.CertificateDetail_FailureReason, &ev); err != nil { + return err + } + v.FailureReason = FailureReason(ev) + return nil + case schemas.CertificateDetail_ImportedAt: + v.ImportedAt = new(time.Time) + return d.ReadTime(schemas.CertificateDetail_ImportedAt, v.ImportedAt) + case schemas.CertificateDetail_InUseBy: + return deserializeInUseList(d, schemas.CertificateDetail_InUseBy, &v.InUseBy) + case schemas.CertificateDetail_IssuedAt: + v.IssuedAt = new(time.Time) + return d.ReadTime(schemas.CertificateDetail_IssuedAt, v.IssuedAt) + case schemas.CertificateDetail_Issuer: + v.Issuer = new(string) + return d.ReadString(schemas.CertificateDetail_Issuer, v.Issuer) + case schemas.CertificateDetail_KeyAlgorithm: + var ev string + if err := d.ReadString(schemas.CertificateDetail_KeyAlgorithm, &ev); err != nil { + return err + } + v.KeyAlgorithm = KeyAlgorithm(ev) + return nil + case schemas.CertificateDetail_KeyUsages: + return deserializeKeyUsageList(d, schemas.CertificateDetail_KeyUsages, &v.KeyUsages) + case schemas.CertificateDetail_ManagedBy: + var ev string + if err := d.ReadString(schemas.CertificateDetail_ManagedBy, &ev); err != nil { + return err + } + v.ManagedBy = CertificateManagedBy(ev) + return nil + case schemas.CertificateDetail_NotAfter: + v.NotAfter = new(time.Time) + return d.ReadTime(schemas.CertificateDetail_NotAfter, v.NotAfter) + case schemas.CertificateDetail_NotBefore: + v.NotBefore = new(time.Time) + return d.ReadTime(schemas.CertificateDetail_NotBefore, v.NotBefore) + case schemas.CertificateDetail_Options: + v.Options = &CertificateOptions{} + return v.Options.Deserialize(d) + case schemas.CertificateDetail_RenewalEligibility: + var ev string + if err := d.ReadString(schemas.CertificateDetail_RenewalEligibility, &ev); err != nil { + return err + } + v.RenewalEligibility = RenewalEligibility(ev) + return nil + case schemas.CertificateDetail_RenewalSummary: + v.RenewalSummary = &RenewalSummary{} + return v.RenewalSummary.Deserialize(d) + case schemas.CertificateDetail_RevocationReason: + var ev string + if err := d.ReadString(schemas.CertificateDetail_RevocationReason, &ev); err != nil { + return err + } + v.RevocationReason = RevocationReason(ev) + return nil + case schemas.CertificateDetail_RevokedAt: + v.RevokedAt = new(time.Time) + return d.ReadTime(schemas.CertificateDetail_RevokedAt, v.RevokedAt) + case schemas.CertificateDetail_Serial: + v.Serial = new(string) + return d.ReadString(schemas.CertificateDetail_Serial, v.Serial) + case schemas.CertificateDetail_SignatureAlgorithm: + v.SignatureAlgorithm = new(string) + return d.ReadString(schemas.CertificateDetail_SignatureAlgorithm, v.SignatureAlgorithm) + case schemas.CertificateDetail_Status: + var ev string + if err := d.ReadString(schemas.CertificateDetail_Status, &ev); err != nil { + return err + } + v.Status = CertificateStatus(ev) + return nil + case schemas.CertificateDetail_Subject: + v.Subject = new(string) + return d.ReadString(schemas.CertificateDetail_Subject, v.Subject) + case schemas.CertificateDetail_SubjectAlternativeNames: + return deserializeDomainList(d, schemas.CertificateDetail_SubjectAlternativeNames, &v.SubjectAlternativeNames) + case schemas.CertificateDetail_Type: + var ev string + if err := d.ReadString(schemas.CertificateDetail_Type, &ev); err != nil { + return err + } + v.Type = CertificateType(ev) + return nil + case schemas.CertificateDetail_UpdateSummary: + v.UpdateSummary = &UpdateSummary{} + return v.UpdateSummary.Deserialize(d) + } + return nil + }) +} + // Defines a filter for searching certificates by ARN, X.509 attributes, or ACM // metadata. // @@ -328,6 +1681,12 @@ type CertificateFilterMemberAcmCertificateMetadataFilter struct { } func (*CertificateFilterMemberAcmCertificateMetadataFilter) isCertificateFilter() {} +func (v *CertificateFilterMemberAcmCertificateMetadataFilter) Serialize(s smithy.ShapeSerializer) { + serializeAcmCertificateMetadataFilter(s, schemas.CertificateFilter_AcmCertificateMetadataFilter, v.Value) +} +func (v *CertificateFilterMemberAcmCertificateMetadataFilter) Deserialize(d smithy.ShapeDeserializer) error { + return deserializeAcmCertificateMetadataFilter(d, schemas.CertificateFilter_AcmCertificateMetadataFilter, &v.Value) +} // Filter by certificate ARN. type CertificateFilterMemberCertificateArn struct { @@ -337,6 +1696,12 @@ type CertificateFilterMemberCertificateArn struct { } func (*CertificateFilterMemberCertificateArn) isCertificateFilter() {} +func (v *CertificateFilterMemberCertificateArn) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.CertificateFilter_CertificateArn, v.Value) +} +func (v *CertificateFilterMemberCertificateArn) Deserialize(d smithy.ShapeDeserializer) error { + return d.ReadString(schemas.CertificateFilter_CertificateArn, &v.Value) +} // Filter by X.509 certificate attributes. type CertificateFilterMemberX509AttributeFilter struct { @@ -346,6 +1711,12 @@ type CertificateFilterMemberX509AttributeFilter struct { } func (*CertificateFilterMemberX509AttributeFilter) isCertificateFilter() {} +func (v *CertificateFilterMemberX509AttributeFilter) Serialize(s smithy.ShapeSerializer) { + serializeX509AttributeFilter(s, schemas.CertificateFilter_X509AttributeFilter, v.Value) +} +func (v *CertificateFilterMemberX509AttributeFilter) Deserialize(d smithy.ShapeDeserializer) error { + return deserializeX509AttributeFilter(d, schemas.CertificateFilter_X509AttributeFilter, &v.Value) +} // A filter statement used to search for certificates. Can contain AND, OR, NOT // logical operators or a single filter. @@ -368,6 +1739,12 @@ type CertificateFilterStatementMemberAnd struct { } func (*CertificateFilterStatementMemberAnd) isCertificateFilterStatement() {} +func (v *CertificateFilterStatementMemberAnd) Serialize(s smithy.ShapeSerializer) { + serializeCertificateFilterStatementList(s, schemas.CertificateFilterStatement_And, v.Value) +} +func (v *CertificateFilterStatementMemberAnd) Deserialize(d smithy.ShapeDeserializer) error { + return deserializeCertificateFilterStatementList(d, schemas.CertificateFilterStatement_And, &v.Value) +} // A single certificate filter. type CertificateFilterStatementMemberFilter struct { @@ -377,6 +1754,12 @@ type CertificateFilterStatementMemberFilter struct { } func (*CertificateFilterStatementMemberFilter) isCertificateFilterStatement() {} +func (v *CertificateFilterStatementMemberFilter) Serialize(s smithy.ShapeSerializer) { + serializeCertificateFilter(s, schemas.CertificateFilterStatement_Filter, v.Value) +} +func (v *CertificateFilterStatementMemberFilter) Deserialize(d smithy.ShapeDeserializer) error { + return deserializeCertificateFilter(d, schemas.CertificateFilterStatement_Filter, &v.Value) +} // A filter statement that must not be true. type CertificateFilterStatementMemberNot struct { @@ -386,6 +1769,12 @@ type CertificateFilterStatementMemberNot struct { } func (*CertificateFilterStatementMemberNot) isCertificateFilterStatement() {} +func (v *CertificateFilterStatementMemberNot) Serialize(s smithy.ShapeSerializer) { + serializeCertificateFilterStatement(s, schemas.CertificateFilterStatement_Not, v.Value) +} +func (v *CertificateFilterStatementMemberNot) Deserialize(d smithy.ShapeDeserializer) error { + return deserializeCertificateFilterStatement(d, schemas.CertificateFilterStatement_Not, &v.Value) +} // A list of filter statements where at least one must be true. type CertificateFilterStatementMemberOr struct { @@ -395,6 +1784,12 @@ type CertificateFilterStatementMemberOr struct { } func (*CertificateFilterStatementMemberOr) isCertificateFilterStatement() {} +func (v *CertificateFilterStatementMemberOr) Serialize(s smithy.ShapeSerializer) { + serializeCertificateFilterStatementList(s, schemas.CertificateFilterStatement_Or, v.Value) +} +func (v *CertificateFilterStatementMemberOr) Deserialize(d smithy.ShapeDeserializer) error { + return deserializeCertificateFilterStatementList(d, schemas.CertificateFilterStatement_Or, &v.Value) +} // Contains metadata about a certificate. Currently supports ACM certificate // metadata. @@ -414,16 +1809,21 @@ type CertificateMetadataMemberAcmCertificateMetadata struct { } func (*CertificateMetadataMemberAcmCertificateMetadata) isCertificateMetadata() {} +func (v *CertificateMetadataMemberAcmCertificateMetadata) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CertificateMetadata_AcmCertificateMetadata) + v.Value.SerializeMembers(s) + s.CloseStruct() +} +func (v *CertificateMetadataMemberAcmCertificateMetadata) Deserialize(d smithy.ShapeDeserializer) error { + return v.Value.Deserialize(d) +} // Structure that contains options for your certificate. You can use this -// structure to specify whether to opt in to or out of certificate transparency -// logging and export your certificate. +// structure to change the domain validation method or specify whether to export +// your certificate. // -// Some browsers require that public certificates issued for your domain be -// recorded in a log. Certificates that are not logged typically generate a browser -// error. Transparency makes it possible for you to detect SSL/TLS certificates -// that have been mistakenly or maliciously issued for your domain. For general -// information, see [Certificate Transparency Logging]. +// All public certificates are recorded in a certificate transparency log. For +// general information, see [Certificate Transparency Logging]. // // You can export public ACM certificates to use with Amazon Web Services services // as well as outside Amazon Web Services Cloud. For more information, see [Certificate Manager exportable public certificate]. @@ -432,17 +1832,70 @@ func (*CertificateMetadataMemberAcmCertificateMetadata) isCertificateMetadata() // [Certificate Transparency Logging]: https://docs.aws.amazon.com/acm/latest/userguide/acm-concepts.html#concept-transparency type CertificateOptions struct { - // You can opt out of certificate transparency logging by specifying the DISABLED - // option. Opt in by specifying ENABLED . + // This parameter has been deprecated. Certificate transparency logging opt-out is + // no longer available. All public certificates are recorded in a certificate + // transparency log. + // + // Deprecated: Certificate transparency logging opt-out is no longer available. CertificateTransparencyLoggingPreference CertificateTransparencyLoggingPreference // You can opt in to allow the export of your certificates by specifying ENABLED . // You cannot update the value of Export after the the certificate is created. Export CertificateExport + // The domain validation method for the certificate. To migrate from email to DNS + // validation, specify DNS . + ValidationMethod ValidationMethod + noSmithyDocumentSerde } +func (v *CertificateOptions) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CertificateOptions) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CertificateOptions) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateTransparencyLoggingPreference != "" { + s.WriteString(schemas.CertificateOptions_CertificateTransparencyLoggingPreference, string(v.CertificateTransparencyLoggingPreference)) + } + if v.Export != "" { + s.WriteString(schemas.CertificateOptions_Export, string(v.Export)) + } + if v.ValidationMethod != "" { + s.WriteString(schemas.CertificateOptions_ValidationMethod, string(v.ValidationMethod)) + } +} +func (v *CertificateOptions) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.CertificateOptions, func(s *smithy.Schema) error { + switch s { + case schemas.CertificateOptions_CertificateTransparencyLoggingPreference: + var ev string + if err := d.ReadString(schemas.CertificateOptions_CertificateTransparencyLoggingPreference, &ev); err != nil { + return err + } + v.CertificateTransparencyLoggingPreference = CertificateTransparencyLoggingPreference(ev) + return nil + case schemas.CertificateOptions_Export: + var ev string + if err := d.ReadString(schemas.CertificateOptions_Export, &ev); err != nil { + return err + } + v.Export = CertificateExport(ev) + return nil + case schemas.CertificateOptions_ValidationMethod: + var ev string + if err := d.ReadString(schemas.CertificateOptions_ValidationMethod, &ev); err != nil { + return err + } + v.ValidationMethod = ValidationMethod(ev) + return nil + } + return nil + }) +} + // Contains information about a certificate returned by the SearchCertificates action. This // structure includes the certificate ARN, X.509 attributes, and ACM metadata. type CertificateSearchResult struct { @@ -459,6 +1912,39 @@ type CertificateSearchResult struct { noSmithyDocumentSerde } +func (v *CertificateSearchResult) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CertificateSearchResult) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CertificateSearchResult) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.CertificateSearchResult_CertificateArn, *v.CertificateArn) + } + serializeCertificateMetadata(s, schemas.CertificateSearchResult_CertificateMetadata, v.CertificateMetadata) + if v.X509Attributes != nil { + s.WriteStruct(schemas.CertificateSearchResult_X509Attributes) + v.X509Attributes.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *CertificateSearchResult) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.CertificateSearchResult, func(s *smithy.Schema) error { + switch s { + case schemas.CertificateSearchResult_CertificateArn: + v.CertificateArn = new(string) + return d.ReadString(schemas.CertificateSearchResult_CertificateArn, v.CertificateArn) + case schemas.CertificateSearchResult_CertificateMetadata: + return deserializeCertificateMetadata(d, schemas.CertificateSearchResult_CertificateMetadata, &v.CertificateMetadata) + case schemas.CertificateSearchResult_X509Attributes: + v.X509Attributes = &X509Attributes{} + return v.X509Attributes.Deserialize(d) + } + return nil + }) +} + // This structure is returned in the response object of ListCertificates action. type CertificateSummary struct { @@ -471,6 +1957,9 @@ type CertificateSummary struct { // [Amazon Resource Names (ARNs)]: https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html CertificateArn *string + // The origin of the certificate's key pair. + CertificateKeyPairOrigin CertificateKeyPairOrigin + // The time at which the certificate was requested. CreatedAt *time.Time @@ -481,8 +1970,7 @@ type CertificateSummary struct { // Indicates if export is enabled for the certificate. ExportOption CertificateExport - // Indicates whether the certificate has been exported. This value exists only - // when the certificate type is PRIVATE . + // Indicates whether the certificate has been exported. Exported *bool // Contains a list of Extended Key Usage X.509 v3 extension objects. Each object @@ -580,7 +2068,168 @@ type CertificateSummary struct { noSmithyDocumentSerde } -// Filters certificates by common name. +func (v *CertificateSummary) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CertificateSummary) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CertificateSummary) SerializeMembers(s smithy.ShapeSerializer) { + if v.CertificateArn != nil { + s.WriteString(schemas.CertificateSummary_CertificateArn, *v.CertificateArn) + } + if v.CertificateKeyPairOrigin != "" { + s.WriteString(schemas.CertificateSummary_CertificateKeyPairOrigin, string(v.CertificateKeyPairOrigin)) + } + if v.CreatedAt != nil { + s.WriteTime(schemas.CertificateSummary_CreatedAt, *v.CreatedAt) + } + if v.DomainName != nil { + s.WriteString(schemas.CertificateSummary_DomainName, *v.DomainName) + } + if v.ExportOption != "" { + s.WriteString(schemas.CertificateSummary_ExportOption, string(v.ExportOption)) + } + if v.Exported != nil { + s.WriteBool(schemas.CertificateSummary_Exported, *v.Exported) + } + serializeExtendedKeyUsageNames(s, schemas.CertificateSummary_ExtendedKeyUsages, v.ExtendedKeyUsages) + if v.HasAdditionalSubjectAlternativeNames != nil { + s.WriteBool(schemas.CertificateSummary_HasAdditionalSubjectAlternativeNames, *v.HasAdditionalSubjectAlternativeNames) + } + if v.ImportedAt != nil { + s.WriteTime(schemas.CertificateSummary_ImportedAt, *v.ImportedAt) + } + if v.InUse != nil { + s.WriteBool(schemas.CertificateSummary_InUse, *v.InUse) + } + if v.IssuedAt != nil { + s.WriteTime(schemas.CertificateSummary_IssuedAt, *v.IssuedAt) + } + if v.KeyAlgorithm != "" { + s.WriteString(schemas.CertificateSummary_KeyAlgorithm, string(v.KeyAlgorithm)) + } + serializeKeyUsageNames(s, schemas.CertificateSummary_KeyUsages, v.KeyUsages) + if v.ManagedBy != "" { + s.WriteString(schemas.CertificateSummary_ManagedBy, string(v.ManagedBy)) + } + if v.NotAfter != nil { + s.WriteTime(schemas.CertificateSummary_NotAfter, *v.NotAfter) + } + if v.NotBefore != nil { + s.WriteTime(schemas.CertificateSummary_NotBefore, *v.NotBefore) + } + if v.RenewalEligibility != "" { + s.WriteString(schemas.CertificateSummary_RenewalEligibility, string(v.RenewalEligibility)) + } + if v.RevokedAt != nil { + s.WriteTime(schemas.CertificateSummary_RevokedAt, *v.RevokedAt) + } + if v.Status != "" { + s.WriteString(schemas.CertificateSummary_Status, string(v.Status)) + } + serializeDomainList(s, schemas.CertificateSummary_SubjectAlternativeNameSummaries, v.SubjectAlternativeNameSummaries) + if v.Type != "" { + s.WriteString(schemas.CertificateSummary_Type, string(v.Type)) + } +} +func (v *CertificateSummary) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.CertificateSummary, func(s *smithy.Schema) error { + switch s { + case schemas.CertificateSummary_CertificateArn: + v.CertificateArn = new(string) + return d.ReadString(schemas.CertificateSummary_CertificateArn, v.CertificateArn) + case schemas.CertificateSummary_CertificateKeyPairOrigin: + var ev string + if err := d.ReadString(schemas.CertificateSummary_CertificateKeyPairOrigin, &ev); err != nil { + return err + } + v.CertificateKeyPairOrigin = CertificateKeyPairOrigin(ev) + return nil + case schemas.CertificateSummary_CreatedAt: + v.CreatedAt = new(time.Time) + return d.ReadTime(schemas.CertificateSummary_CreatedAt, v.CreatedAt) + case schemas.CertificateSummary_DomainName: + v.DomainName = new(string) + return d.ReadString(schemas.CertificateSummary_DomainName, v.DomainName) + case schemas.CertificateSummary_ExportOption: + var ev string + if err := d.ReadString(schemas.CertificateSummary_ExportOption, &ev); err != nil { + return err + } + v.ExportOption = CertificateExport(ev) + return nil + case schemas.CertificateSummary_Exported: + v.Exported = new(bool) + return d.ReadBool(schemas.CertificateSummary_Exported, v.Exported) + case schemas.CertificateSummary_ExtendedKeyUsages: + return deserializeExtendedKeyUsageNames(d, schemas.CertificateSummary_ExtendedKeyUsages, &v.ExtendedKeyUsages) + case schemas.CertificateSummary_HasAdditionalSubjectAlternativeNames: + v.HasAdditionalSubjectAlternativeNames = new(bool) + return d.ReadBool(schemas.CertificateSummary_HasAdditionalSubjectAlternativeNames, v.HasAdditionalSubjectAlternativeNames) + case schemas.CertificateSummary_ImportedAt: + v.ImportedAt = new(time.Time) + return d.ReadTime(schemas.CertificateSummary_ImportedAt, v.ImportedAt) + case schemas.CertificateSummary_InUse: + v.InUse = new(bool) + return d.ReadBool(schemas.CertificateSummary_InUse, v.InUse) + case schemas.CertificateSummary_IssuedAt: + v.IssuedAt = new(time.Time) + return d.ReadTime(schemas.CertificateSummary_IssuedAt, v.IssuedAt) + case schemas.CertificateSummary_KeyAlgorithm: + var ev string + if err := d.ReadString(schemas.CertificateSummary_KeyAlgorithm, &ev); err != nil { + return err + } + v.KeyAlgorithm = KeyAlgorithm(ev) + return nil + case schemas.CertificateSummary_KeyUsages: + return deserializeKeyUsageNames(d, schemas.CertificateSummary_KeyUsages, &v.KeyUsages) + case schemas.CertificateSummary_ManagedBy: + var ev string + if err := d.ReadString(schemas.CertificateSummary_ManagedBy, &ev); err != nil { + return err + } + v.ManagedBy = CertificateManagedBy(ev) + return nil + case schemas.CertificateSummary_NotAfter: + v.NotAfter = new(time.Time) + return d.ReadTime(schemas.CertificateSummary_NotAfter, v.NotAfter) + case schemas.CertificateSummary_NotBefore: + v.NotBefore = new(time.Time) + return d.ReadTime(schemas.CertificateSummary_NotBefore, v.NotBefore) + case schemas.CertificateSummary_RenewalEligibility: + var ev string + if err := d.ReadString(schemas.CertificateSummary_RenewalEligibility, &ev); err != nil { + return err + } + v.RenewalEligibility = RenewalEligibility(ev) + return nil + case schemas.CertificateSummary_RevokedAt: + v.RevokedAt = new(time.Time) + return d.ReadTime(schemas.CertificateSummary_RevokedAt, v.RevokedAt) + case schemas.CertificateSummary_Status: + var ev string + if err := d.ReadString(schemas.CertificateSummary_Status, &ev); err != nil { + return err + } + v.Status = CertificateStatus(ev) + return nil + case schemas.CertificateSummary_SubjectAlternativeNameSummaries: + return deserializeDomainList(d, schemas.CertificateSummary_SubjectAlternativeNameSummaries, &v.SubjectAlternativeNameSummaries) + case schemas.CertificateSummary_Type: + var ev string + if err := d.ReadString(schemas.CertificateSummary_Type, &ev); err != nil { + return err + } + v.Type = CertificateType(ev) + return nil + } + return nil + }) +} + +// Filters certificates by common name. type CommonNameFilter struct { // The comparison operator to use. @@ -596,6 +2245,38 @@ type CommonNameFilter struct { noSmithyDocumentSerde } +func (v *CommonNameFilter) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CommonNameFilter) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CommonNameFilter) SerializeMembers(s smithy.ShapeSerializer) { + if v.ComparisonOperator != "" { + s.WriteString(schemas.CommonNameFilter_ComparisonOperator, string(v.ComparisonOperator)) + } + if v.Value != nil { + s.WriteString(schemas.CommonNameFilter_Value, *v.Value) + } +} +func (v *CommonNameFilter) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.CommonNameFilter, func(s *smithy.Schema) error { + switch s { + case schemas.CommonNameFilter_ComparisonOperator: + var ev string + if err := d.ReadString(schemas.CommonNameFilter_ComparisonOperator, &ev); err != nil { + return err + } + v.ComparisonOperator = ComparisonOperator(ev) + return nil + case schemas.CommonNameFilter_Value: + v.Value = new(string) + return d.ReadString(schemas.CommonNameFilter_Value, v.Value) + } + return nil + }) +} + // Defines the X.500 relative distinguished name (RDN). type CustomAttribute struct { @@ -609,6 +2290,34 @@ type CustomAttribute struct { noSmithyDocumentSerde } +func (v *CustomAttribute) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CustomAttribute) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CustomAttribute) SerializeMembers(s smithy.ShapeSerializer) { + if v.ObjectIdentifier != nil { + s.WriteString(schemas.CustomAttribute_ObjectIdentifier, *v.ObjectIdentifier) + } + if v.Value != nil { + s.WriteString(schemas.CustomAttribute_Value, *v.Value) + } +} +func (v *CustomAttribute) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.CustomAttribute, func(s *smithy.Schema) error { + switch s { + case schemas.CustomAttribute_ObjectIdentifier: + v.ObjectIdentifier = new(string) + return d.ReadString(schemas.CustomAttribute_ObjectIdentifier, v.ObjectIdentifier) + case schemas.CustomAttribute_Value: + v.Value = new(string) + return d.ReadString(schemas.CustomAttribute_Value, v.Value) + } + return nil + }) +} + // Contains X.500 distinguished name information. type DistinguishedName struct { @@ -664,6 +2373,112 @@ type DistinguishedName struct { noSmithyDocumentSerde } +func (v *DistinguishedName) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DistinguishedName) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DistinguishedName) SerializeMembers(s smithy.ShapeSerializer) { + if v.CommonName != nil { + s.WriteString(schemas.DistinguishedName_CommonName, *v.CommonName) + } + if v.Country != nil { + s.WriteString(schemas.DistinguishedName_Country, *v.Country) + } + serializeCustomAttributeList(s, schemas.DistinguishedName_CustomAttributes, v.CustomAttributes) + if v.DistinguishedNameQualifier != nil { + s.WriteString(schemas.DistinguishedName_DistinguishedNameQualifier, *v.DistinguishedNameQualifier) + } + serializeDomainComponentList(s, schemas.DistinguishedName_DomainComponents, v.DomainComponents) + if v.GenerationQualifier != nil { + s.WriteString(schemas.DistinguishedName_GenerationQualifier, *v.GenerationQualifier) + } + if v.GivenName != nil { + s.WriteString(schemas.DistinguishedName_GivenName, *v.GivenName) + } + if v.Initials != nil { + s.WriteString(schemas.DistinguishedName_Initials, *v.Initials) + } + if v.Locality != nil { + s.WriteString(schemas.DistinguishedName_Locality, *v.Locality) + } + if v.Organization != nil { + s.WriteString(schemas.DistinguishedName_Organization, *v.Organization) + } + if v.OrganizationalUnit != nil { + s.WriteString(schemas.DistinguishedName_OrganizationalUnit, *v.OrganizationalUnit) + } + if v.Pseudonym != nil { + s.WriteString(schemas.DistinguishedName_Pseudonym, *v.Pseudonym) + } + if v.SerialNumber != nil { + s.WriteString(schemas.DistinguishedName_SerialNumber, *v.SerialNumber) + } + if v.State != nil { + s.WriteString(schemas.DistinguishedName_State, *v.State) + } + if v.Surname != nil { + s.WriteString(schemas.DistinguishedName_Surname, *v.Surname) + } + if v.Title != nil { + s.WriteString(schemas.DistinguishedName_Title, *v.Title) + } +} +func (v *DistinguishedName) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DistinguishedName, func(s *smithy.Schema) error { + switch s { + case schemas.DistinguishedName_CommonName: + v.CommonName = new(string) + return d.ReadString(schemas.DistinguishedName_CommonName, v.CommonName) + case schemas.DistinguishedName_Country: + v.Country = new(string) + return d.ReadString(schemas.DistinguishedName_Country, v.Country) + case schemas.DistinguishedName_CustomAttributes: + return deserializeCustomAttributeList(d, schemas.DistinguishedName_CustomAttributes, &v.CustomAttributes) + case schemas.DistinguishedName_DistinguishedNameQualifier: + v.DistinguishedNameQualifier = new(string) + return d.ReadString(schemas.DistinguishedName_DistinguishedNameQualifier, v.DistinguishedNameQualifier) + case schemas.DistinguishedName_DomainComponents: + return deserializeDomainComponentList(d, schemas.DistinguishedName_DomainComponents, &v.DomainComponents) + case schemas.DistinguishedName_GenerationQualifier: + v.GenerationQualifier = new(string) + return d.ReadString(schemas.DistinguishedName_GenerationQualifier, v.GenerationQualifier) + case schemas.DistinguishedName_GivenName: + v.GivenName = new(string) + return d.ReadString(schemas.DistinguishedName_GivenName, v.GivenName) + case schemas.DistinguishedName_Initials: + v.Initials = new(string) + return d.ReadString(schemas.DistinguishedName_Initials, v.Initials) + case schemas.DistinguishedName_Locality: + v.Locality = new(string) + return d.ReadString(schemas.DistinguishedName_Locality, v.Locality) + case schemas.DistinguishedName_Organization: + v.Organization = new(string) + return d.ReadString(schemas.DistinguishedName_Organization, v.Organization) + case schemas.DistinguishedName_OrganizationalUnit: + v.OrganizationalUnit = new(string) + return d.ReadString(schemas.DistinguishedName_OrganizationalUnit, v.OrganizationalUnit) + case schemas.DistinguishedName_Pseudonym: + v.Pseudonym = new(string) + return d.ReadString(schemas.DistinguishedName_Pseudonym, v.Pseudonym) + case schemas.DistinguishedName_SerialNumber: + v.SerialNumber = new(string) + return d.ReadString(schemas.DistinguishedName_SerialNumber, v.SerialNumber) + case schemas.DistinguishedName_State: + v.State = new(string) + return d.ReadString(schemas.DistinguishedName_State, v.State) + case schemas.DistinguishedName_Surname: + v.Surname = new(string) + return d.ReadString(schemas.DistinguishedName_Surname, v.Surname) + case schemas.DistinguishedName_Title: + v.Title = new(string) + return d.ReadString(schemas.DistinguishedName_Title, v.Title) + } + return nil + }) +} + // Filters certificates by DNS name. type DnsNameFilter struct { @@ -680,6 +2495,229 @@ type DnsNameFilter struct { noSmithyDocumentSerde } +func (v *DnsNameFilter) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DnsNameFilter) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DnsNameFilter) SerializeMembers(s smithy.ShapeSerializer) { + if v.ComparisonOperator != "" { + s.WriteString(schemas.DnsNameFilter_ComparisonOperator, string(v.ComparisonOperator)) + } + if v.Value != nil { + s.WriteString(schemas.DnsNameFilter_Value, *v.Value) + } +} +func (v *DnsNameFilter) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DnsNameFilter, func(s *smithy.Schema) error { + switch s { + case schemas.DnsNameFilter_ComparisonOperator: + var ev string + if err := d.ReadString(schemas.DnsNameFilter_ComparisonOperator, &ev); err != nil { + return err + } + v.ComparisonOperator = ComparisonOperator(ev) + return nil + case schemas.DnsNameFilter_Value: + v.Value = new(string) + return d.ReadString(schemas.DnsNameFilter_Value, v.Value) + } + return nil + }) +} + +// DNS prevalidation details including the resource record for validation. +type DnsPrevalidationDetails struct { + + // The scope of domains covered by this prevalidation. + DomainScope *DomainScope + + // The Route 53 hosted zone ID for DNS validation. + HostedZoneId *string + + // The DNS resource record to create for domain validation. + ResourceRecord *ResourceRecord + + noSmithyDocumentSerde +} + +func (v *DnsPrevalidationDetails) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DnsPrevalidationDetails) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DnsPrevalidationDetails) SerializeMembers(s smithy.ShapeSerializer) { + if v.DomainScope != nil { + s.WriteStruct(schemas.DnsPrevalidationDetails_DomainScope) + v.DomainScope.SerializeMembers(s) + s.CloseStruct() + } + if v.HostedZoneId != nil { + s.WriteString(schemas.DnsPrevalidationDetails_HostedZoneId, *v.HostedZoneId) + } + if v.ResourceRecord != nil { + s.WriteStruct(schemas.DnsPrevalidationDetails_ResourceRecord) + v.ResourceRecord.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *DnsPrevalidationDetails) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DnsPrevalidationDetails, func(s *smithy.Schema) error { + switch s { + case schemas.DnsPrevalidationDetails_DomainScope: + v.DomainScope = &DomainScope{} + return v.DomainScope.Deserialize(d) + case schemas.DnsPrevalidationDetails_HostedZoneId: + v.HostedZoneId = new(string) + return d.ReadString(schemas.DnsPrevalidationDetails_HostedZoneId, v.HostedZoneId) + case schemas.DnsPrevalidationDetails_ResourceRecord: + v.ResourceRecord = &ResourceRecord{} + return v.ResourceRecord.Deserialize(d) + } + return nil + }) +} + +// DNS prevalidation options for domain validation. +type DnsPrevalidationOptions struct { + + // The scope of domains covered by this prevalidation. + DomainScope *DomainScope + + // The Route 53 hosted zone ID for DNS validation. + HostedZoneId *string + + noSmithyDocumentSerde +} + +func (v *DnsPrevalidationOptions) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DnsPrevalidationOptions) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DnsPrevalidationOptions) SerializeMembers(s smithy.ShapeSerializer) { + if v.DomainScope != nil { + s.WriteStruct(schemas.DnsPrevalidationOptions_DomainScope) + v.DomainScope.SerializeMembers(s) + s.CloseStruct() + } + if v.HostedZoneId != nil { + s.WriteString(schemas.DnsPrevalidationOptions_HostedZoneId, *v.HostedZoneId) + } +} +func (v *DnsPrevalidationOptions) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DnsPrevalidationOptions, func(s *smithy.Schema) error { + switch s { + case schemas.DnsPrevalidationOptions_DomainScope: + v.DomainScope = &DomainScope{} + return v.DomainScope.Deserialize(d) + case schemas.DnsPrevalidationOptions_HostedZoneId: + v.HostedZoneId = new(string) + return d.ReadString(schemas.DnsPrevalidationOptions_HostedZoneId, v.HostedZoneId) + } + return nil + }) +} + +// Contains the CNAME record that you must add to your DNS configuration to +// validate domain ownership using DNS validation. +type DnsValidationChallenge struct { + + // The CNAME record that ACM creates for DNS validation. Add this record to your + // DNS configuration to prove that you own or control the domain. + ResourceRecord *ResourceRecord + + noSmithyDocumentSerde +} + +func (v *DnsValidationChallenge) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DnsValidationChallenge) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DnsValidationChallenge) SerializeMembers(s smithy.ShapeSerializer) { + if v.ResourceRecord != nil { + s.WriteStruct(schemas.DnsValidationChallenge_ResourceRecord) + v.ResourceRecord.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *DnsValidationChallenge) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DnsValidationChallenge, func(s *smithy.Schema) error { + switch s { + case schemas.DnsValidationChallenge_ResourceRecord: + v.ResourceRecord = &ResourceRecord{} + return v.ResourceRecord.Deserialize(d) + } + return nil + }) +} + +// Specifies the scope of domain validation. +type DomainScope struct { + + // Whether validation applies to the exact domain. + ExactDomain DomainScopeOption + + // Whether validation applies to subdomains. + Subdomains DomainScopeOption + + // Whether validation applies to wildcard domains. + Wildcards DomainScopeOption + + noSmithyDocumentSerde +} + +func (v *DomainScope) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DomainScope) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DomainScope) SerializeMembers(s smithy.ShapeSerializer) { + if v.ExactDomain != "" { + s.WriteString(schemas.DomainScope_ExactDomain, string(v.ExactDomain)) + } + if v.Subdomains != "" { + s.WriteString(schemas.DomainScope_Subdomains, string(v.Subdomains)) + } + if v.Wildcards != "" { + s.WriteString(schemas.DomainScope_Wildcards, string(v.Wildcards)) + } +} +func (v *DomainScope) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DomainScope, func(s *smithy.Schema) error { + switch s { + case schemas.DomainScope_ExactDomain: + var ev string + if err := d.ReadString(schemas.DomainScope_ExactDomain, &ev); err != nil { + return err + } + v.ExactDomain = DomainScopeOption(ev) + return nil + case schemas.DomainScope_Subdomains: + var ev string + if err := d.ReadString(schemas.DomainScope_Subdomains, &ev); err != nil { + return err + } + v.Subdomains = DomainScopeOption(ev) + return nil + case schemas.DomainScope_Wildcards: + var ev string + if err := d.ReadString(schemas.DomainScope_Wildcards, &ev); err != nil { + return err + } + v.Wildcards = DomainScopeOption(ev) + return nil + } + return nil + }) +} + // Contains information about the validation of each domain name in the // certificate. type DomainValidation struct { @@ -729,6 +2767,122 @@ type DomainValidation struct { noSmithyDocumentSerde } +func (v *DomainValidation) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DomainValidation) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DomainValidation) SerializeMembers(s smithy.ShapeSerializer) { + if v.DomainName != nil { + s.WriteString(schemas.DomainValidation_DomainName, *v.DomainName) + } + if v.HttpRedirect != nil { + s.WriteStruct(schemas.DomainValidation_HttpRedirect) + v.HttpRedirect.SerializeMembers(s) + s.CloseStruct() + } + if v.ResourceRecord != nil { + s.WriteStruct(schemas.DomainValidation_ResourceRecord) + v.ResourceRecord.SerializeMembers(s) + s.CloseStruct() + } + if v.ValidationDomain != nil { + s.WriteString(schemas.DomainValidation_ValidationDomain, *v.ValidationDomain) + } + serializeValidationEmailList(s, schemas.DomainValidation_ValidationEmails, v.ValidationEmails) + if v.ValidationMethod != "" { + s.WriteString(schemas.DomainValidation_ValidationMethod, string(v.ValidationMethod)) + } + if v.ValidationStatus != "" { + s.WriteString(schemas.DomainValidation_ValidationStatus, string(v.ValidationStatus)) + } +} +func (v *DomainValidation) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DomainValidation, func(s *smithy.Schema) error { + switch s { + case schemas.DomainValidation_DomainName: + v.DomainName = new(string) + return d.ReadString(schemas.DomainValidation_DomainName, v.DomainName) + case schemas.DomainValidation_HttpRedirect: + v.HttpRedirect = &HttpRedirect{} + return v.HttpRedirect.Deserialize(d) + case schemas.DomainValidation_ResourceRecord: + v.ResourceRecord = &ResourceRecord{} + return v.ResourceRecord.Deserialize(d) + case schemas.DomainValidation_ValidationDomain: + v.ValidationDomain = new(string) + return d.ReadString(schemas.DomainValidation_ValidationDomain, v.ValidationDomain) + case schemas.DomainValidation_ValidationEmails: + return deserializeValidationEmailList(d, schemas.DomainValidation_ValidationEmails, &v.ValidationEmails) + case schemas.DomainValidation_ValidationMethod: + var ev string + if err := d.ReadString(schemas.DomainValidation_ValidationMethod, &ev); err != nil { + return err + } + v.ValidationMethod = ValidationMethod(ev) + return nil + case schemas.DomainValidation_ValidationStatus: + var ev string + if err := d.ReadString(schemas.DomainValidation_ValidationStatus, &ev); err != nil { + return err + } + v.ValidationStatus = DomainStatus(ev) + return nil + } + return nil + }) +} + +// Contains information about a domain validation method migration, including the +// previous validation method and the target validation method. +type DomainValidationMethodUpdateSummary struct { + + // The validation method that the certificate was using before the update. + From ValidationMethod + + // The target validation method for the update. + To ValidationMethod + + noSmithyDocumentSerde +} + +func (v *DomainValidationMethodUpdateSummary) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DomainValidationMethodUpdateSummary) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DomainValidationMethodUpdateSummary) SerializeMembers(s smithy.ShapeSerializer) { + if v.From != "" { + s.WriteString(schemas.DomainValidationMethodUpdateSummary_From, string(v.From)) + } + if v.To != "" { + s.WriteString(schemas.DomainValidationMethodUpdateSummary_To, string(v.To)) + } +} +func (v *DomainValidationMethodUpdateSummary) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DomainValidationMethodUpdateSummary, func(s *smithy.Schema) error { + switch s { + case schemas.DomainValidationMethodUpdateSummary_From: + var ev string + if err := d.ReadString(schemas.DomainValidationMethodUpdateSummary_From, &ev); err != nil { + return err + } + v.From = ValidationMethod(ev) + return nil + case schemas.DomainValidationMethodUpdateSummary_To: + var ev string + if err := d.ReadString(schemas.DomainValidationMethodUpdateSummary_To, &ev); err != nil { + return err + } + v.To = ValidationMethod(ev) + return nil + } + return nil + }) +} + // Contains information about the domain names that you want ACM to use to send // you emails that enable you to validate domain ownership. type DomainValidationOption struct { @@ -761,6 +2915,182 @@ type DomainValidationOption struct { noSmithyDocumentSerde } +func (v *DomainValidationOption) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DomainValidationOption) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DomainValidationOption) SerializeMembers(s smithy.ShapeSerializer) { + if v.DomainName != nil { + s.WriteString(schemas.DomainValidationOption_DomainName, *v.DomainName) + } + if v.ValidationDomain != nil { + s.WriteString(schemas.DomainValidationOption_ValidationDomain, *v.ValidationDomain) + } +} +func (v *DomainValidationOption) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DomainValidationOption, func(s *smithy.Schema) error { + switch s { + case schemas.DomainValidationOption_DomainName: + v.DomainName = new(string) + return d.ReadString(schemas.DomainValidationOption_DomainName, v.DomainName) + case schemas.DomainValidationOption_ValidationDomain: + v.ValidationDomain = new(string) + return d.ReadString(schemas.DomainValidationOption_ValidationDomain, v.ValidationDomain) + } + return nil + }) +} + +// Contains per-domain validation information for a certificate. This structure is +// returned as a member of the ListCertificateDomainValidationsresponse. +type DomainValidationSummary struct { + + // The fully qualified domain name (FQDN) in the certificate for which this + // validation summary applies. + // + // This member is required. + DomainName *string + + // The validation configuration currently in effect for this domain. This reflects + // the validation method that ACM is currently using to validate domain ownership + // (for example, email or DNS). + ActiveValidationConfiguration *ValidationConfiguration + + // The validation configuration for a pending validation method migration. This + // field is present only when a migration is in progress (for example, from email + // to DNS validation). It contains the target validation method, the current + // validation status, and the validation challenge details (such as the CNAME + // record to add to your DNS configuration). + RequestedValidationConfiguration *ValidationConfiguration + + noSmithyDocumentSerde +} + +func (v *DomainValidationSummary) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DomainValidationSummary) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DomainValidationSummary) SerializeMembers(s smithy.ShapeSerializer) { + if v.ActiveValidationConfiguration != nil { + s.WriteStruct(schemas.DomainValidationSummary_ActiveValidationConfiguration) + v.ActiveValidationConfiguration.SerializeMembers(s) + s.CloseStruct() + } + if v.DomainName != nil { + s.WriteString(schemas.DomainValidationSummary_DomainName, *v.DomainName) + } + if v.RequestedValidationConfiguration != nil { + s.WriteStruct(schemas.DomainValidationSummary_RequestedValidationConfiguration) + v.RequestedValidationConfiguration.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *DomainValidationSummary) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DomainValidationSummary, func(s *smithy.Schema) error { + switch s { + case schemas.DomainValidationSummary_ActiveValidationConfiguration: + v.ActiveValidationConfiguration = &ValidationConfiguration{} + return v.ActiveValidationConfiguration.Deserialize(d) + case schemas.DomainValidationSummary_DomainName: + v.DomainName = new(string) + return d.ReadString(schemas.DomainValidationSummary_DomainName, v.DomainName) + case schemas.DomainValidationSummary_RequestedValidationConfiguration: + v.RequestedValidationConfiguration = &ValidationConfiguration{} + return v.RequestedValidationConfiguration.Deserialize(d) + } + return nil + }) +} + +// Contains the email addresses used for email-based domain validation. +type EmailValidationChallenge struct { + + // The domain name that ACM uses to send validation emails. + ValidationDomain *string + + // A list of email addresses that ACM uses to send domain validation emails. + ValidationEmails []string + + noSmithyDocumentSerde +} + +func (v *EmailValidationChallenge) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.EmailValidationChallenge) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *EmailValidationChallenge) SerializeMembers(s smithy.ShapeSerializer) { + if v.ValidationDomain != nil { + s.WriteString(schemas.EmailValidationChallenge_ValidationDomain, *v.ValidationDomain) + } + serializeValidationEmailList(s, schemas.EmailValidationChallenge_ValidationEmails, v.ValidationEmails) +} +func (v *EmailValidationChallenge) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.EmailValidationChallenge, func(s *smithy.Schema) error { + switch s { + case schemas.EmailValidationChallenge_ValidationDomain: + v.ValidationDomain = new(string) + return d.ReadString(schemas.EmailValidationChallenge_ValidationDomain, v.ValidationDomain) + case schemas.EmailValidationChallenge_ValidationEmails: + return deserializeValidationEmailList(d, schemas.EmailValidationChallenge_ValidationEmails, &v.ValidationEmails) + } + return nil + }) +} + +// Specifies an expiration configuration. +type Expiration struct { + + // The time unit for the expiration value. + // + // This member is required. + Type TimeType + + // The numeric value of the expiration. + // + // This member is required. + Value *int64 + + noSmithyDocumentSerde +} + +func (v *Expiration) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.Expiration) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *Expiration) SerializeMembers(s smithy.ShapeSerializer) { + if v.Type != "" { + s.WriteString(schemas.Expiration_Type, string(v.Type)) + } + if v.Value != nil { + s.WriteInt64(schemas.Expiration_Value, *v.Value) + } +} +func (v *Expiration) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.Expiration, func(s *smithy.Schema) error { + switch s { + case schemas.Expiration_Type: + var ev string + if err := d.ReadString(schemas.Expiration_Type, &ev); err != nil { + return err + } + v.Type = TimeType(ev) + return nil + case schemas.Expiration_Value: + v.Value = new(int64) + return d.ReadInt64(schemas.Expiration_Value, v.Value) + } + return nil + }) +} + // Object containing expiration events options associated with an Amazon Web // Services account. type ExpiryEventsConfiguration struct { @@ -774,6 +3104,28 @@ type ExpiryEventsConfiguration struct { noSmithyDocumentSerde } +func (v *ExpiryEventsConfiguration) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ExpiryEventsConfiguration) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ExpiryEventsConfiguration) SerializeMembers(s smithy.ShapeSerializer) { + if v.DaysBeforeExpiry != nil { + s.WriteInt32(schemas.ExpiryEventsConfiguration_DaysBeforeExpiry, *v.DaysBeforeExpiry) + } +} +func (v *ExpiryEventsConfiguration) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ExpiryEventsConfiguration, func(s *smithy.Schema) error { + switch s { + case schemas.ExpiryEventsConfiguration_DaysBeforeExpiry: + v.DaysBeforeExpiry = new(int32) + return d.ReadInt32(schemas.ExpiryEventsConfiguration_DaysBeforeExpiry, v.DaysBeforeExpiry) + } + return nil + }) +} + // The Extended Key Usage X.509 v3 extension defines one or more purposes for // which the public key can be used. This is in addition to or in place of the // basic purposes specified by the Key Usage extension. @@ -807,6 +3159,82 @@ type ExtendedKeyUsage struct { noSmithyDocumentSerde } +func (v *ExtendedKeyUsage) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ExtendedKeyUsage) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ExtendedKeyUsage) SerializeMembers(s smithy.ShapeSerializer) { + if v.Name != "" { + s.WriteString(schemas.ExtendedKeyUsage_Name, string(v.Name)) + } + if v.OID != nil { + s.WriteString(schemas.ExtendedKeyUsage_OID, *v.OID) + } +} +func (v *ExtendedKeyUsage) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ExtendedKeyUsage, func(s *smithy.Schema) error { + switch s { + case schemas.ExtendedKeyUsage_Name: + var ev string + if err := d.ReadString(schemas.ExtendedKeyUsage_Name, &ev); err != nil { + return err + } + v.Name = ExtendedKeyUsageName(ev) + return nil + case schemas.ExtendedKeyUsage_OID: + v.OID = new(string) + return d.ReadString(schemas.ExtendedKeyUsage_OID, v.OID) + } + return nil + }) +} + +// Contains details about a failure. +type FailureDetails struct { + + // A message describing the failure. + Message *string + + // The reason for the failure. + Reason AcmeDomainValidationFailureReason + + noSmithyDocumentSerde +} + +func (v *FailureDetails) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.FailureDetails) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *FailureDetails) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.FailureDetails_Message, *v.Message) + } + if v.Reason != "" { + s.WriteString(schemas.FailureDetails_Reason, string(v.Reason)) + } +} +func (v *FailureDetails) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.FailureDetails, func(s *smithy.Schema) error { + switch s { + case schemas.FailureDetails_Message: + v.Message = new(string) + return d.ReadString(schemas.FailureDetails_Message, v.Message) + case schemas.FailureDetails_Reason: + var ev string + if err := d.ReadString(schemas.FailureDetails_Reason, &ev); err != nil { + return err + } + v.Reason = AcmeDomainValidationFailureReason(ev) + return nil + } + return nil + }) +} + // This structure can be used in the ListCertificates action to filter the output of the // certificate list. type Filters struct { @@ -835,6 +3263,51 @@ type Filters struct { noSmithyDocumentSerde } +func (v *Filters) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.Filters) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *Filters) SerializeMembers(s smithy.ShapeSerializer) { + if v.ExportOption != "" { + s.WriteString(schemas.Filters_exportOption, string(v.ExportOption)) + } + serializeExtendedKeyUsageFilterList(s, schemas.Filters_extendedKeyUsage, v.ExtendedKeyUsage) + serializeKeyAlgorithmList(s, schemas.Filters_keyTypes, v.KeyTypes) + serializeKeyUsageFilterList(s, schemas.Filters_keyUsage, v.KeyUsage) + if v.ManagedBy != "" { + s.WriteString(schemas.Filters_managedBy, string(v.ManagedBy)) + } +} +func (v *Filters) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.Filters, func(s *smithy.Schema) error { + switch s { + case schemas.Filters_exportOption: + var ev string + if err := d.ReadString(schemas.Filters_exportOption, &ev); err != nil { + return err + } + v.ExportOption = CertificateExport(ev) + return nil + case schemas.Filters_extendedKeyUsage: + return deserializeExtendedKeyUsageFilterList(d, schemas.Filters_extendedKeyUsage, &v.ExtendedKeyUsage) + case schemas.Filters_keyTypes: + return deserializeKeyAlgorithmList(d, schemas.Filters_keyTypes, &v.KeyTypes) + case schemas.Filters_keyUsage: + return deserializeKeyUsageFilterList(d, schemas.Filters_keyUsage, &v.KeyUsage) + case schemas.Filters_managedBy: + var ev string + if err := d.ReadString(schemas.Filters_managedBy, &ev); err != nil { + return err + } + v.ManagedBy = CertificateManagedBy(ev) + return nil + } + return nil + }) +} + // Describes an ASN.1 X.400 GeneralName as defined in [RFC 5280]. Only one of the following // naming options should be provided. // @@ -865,6 +3338,14 @@ type GeneralNameMemberDirectoryName struct { } func (*GeneralNameMemberDirectoryName) isGeneralName() {} +func (v *GeneralNameMemberDirectoryName) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GeneralName_DirectoryName) + v.Value.SerializeMembers(s) + s.CloseStruct() +} +func (v *GeneralNameMemberDirectoryName) Deserialize(d smithy.ShapeDeserializer) error { + return v.Value.Deserialize(d) +} // Represents GeneralName as a DNS name. type GeneralNameMemberDnsName struct { @@ -874,6 +3355,12 @@ type GeneralNameMemberDnsName struct { } func (*GeneralNameMemberDnsName) isGeneralName() {} +func (v *GeneralNameMemberDnsName) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.GeneralName_DnsName, v.Value) +} +func (v *GeneralNameMemberDnsName) Deserialize(d smithy.ShapeDeserializer) error { + return d.ReadString(schemas.GeneralName_DnsName, &v.Value) +} // Represents GeneralName as an IPv4 or IPv6 address. type GeneralNameMemberIpAddress struct { @@ -883,6 +3370,12 @@ type GeneralNameMemberIpAddress struct { } func (*GeneralNameMemberIpAddress) isGeneralName() {} +func (v *GeneralNameMemberIpAddress) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.GeneralName_IpAddress, v.Value) +} +func (v *GeneralNameMemberIpAddress) Deserialize(d smithy.ShapeDeserializer) error { + return d.ReadString(schemas.GeneralName_IpAddress, &v.Value) +} // Represents GeneralName using an OtherName object. type GeneralNameMemberOtherName struct { @@ -892,6 +3385,14 @@ type GeneralNameMemberOtherName struct { } func (*GeneralNameMemberOtherName) isGeneralName() {} +func (v *GeneralNameMemberOtherName) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GeneralName_OtherName) + v.Value.SerializeMembers(s) + s.CloseStruct() +} +func (v *GeneralNameMemberOtherName) Deserialize(d smithy.ShapeDeserializer) error { + return v.Value.Deserialize(d) +} // Represents GeneralName as an object identifier (OID). type GeneralNameMemberRegisteredId struct { @@ -901,6 +3402,12 @@ type GeneralNameMemberRegisteredId struct { } func (*GeneralNameMemberRegisteredId) isGeneralName() {} +func (v *GeneralNameMemberRegisteredId) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.GeneralName_RegisteredId, v.Value) +} +func (v *GeneralNameMemberRegisteredId) Deserialize(d smithy.ShapeDeserializer) error { + return d.ReadString(schemas.GeneralName_RegisteredId, &v.Value) +} // Represents GeneralName as an [RFC 822] email address. // @@ -912,6 +3419,12 @@ type GeneralNameMemberRfc822Name struct { } func (*GeneralNameMemberRfc822Name) isGeneralName() {} +func (v *GeneralNameMemberRfc822Name) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.GeneralName_Rfc822Name, v.Value) +} +func (v *GeneralNameMemberRfc822Name) Deserialize(d smithy.ShapeDeserializer) error { + return d.ReadString(schemas.GeneralName_Rfc822Name, &v.Value) +} // Represents GeneralName as a URI. type GeneralNameMemberUniformResourceIdentifier struct { @@ -921,6 +3434,12 @@ type GeneralNameMemberUniformResourceIdentifier struct { } func (*GeneralNameMemberUniformResourceIdentifier) isGeneralName() {} +func (v *GeneralNameMemberUniformResourceIdentifier) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.GeneralName_UniformResourceIdentifier, v.Value) +} +func (v *GeneralNameMemberUniformResourceIdentifier) Deserialize(d smithy.ShapeDeserializer) error { + return d.ReadString(schemas.GeneralName_UniformResourceIdentifier, &v.Value) +} // Contains information for HTTP-based domain validation of certificates requested // through Amazon CloudFront and issued by ACM. This field exists only when the @@ -938,6 +3457,34 @@ type HttpRedirect struct { noSmithyDocumentSerde } +func (v *HttpRedirect) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.HttpRedirect) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *HttpRedirect) SerializeMembers(s smithy.ShapeSerializer) { + if v.RedirectFrom != nil { + s.WriteString(schemas.HttpRedirect_RedirectFrom, *v.RedirectFrom) + } + if v.RedirectTo != nil { + s.WriteString(schemas.HttpRedirect_RedirectTo, *v.RedirectTo) + } +} +func (v *HttpRedirect) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.HttpRedirect, func(s *smithy.Schema) error { + switch s { + case schemas.HttpRedirect_RedirectFrom: + v.RedirectFrom = new(string) + return d.ReadString(schemas.HttpRedirect_RedirectFrom, v.RedirectFrom) + case schemas.HttpRedirect_RedirectTo: + v.RedirectTo = new(string) + return d.ReadString(schemas.HttpRedirect_RedirectTo, v.RedirectTo) + } + return nil + }) +} + // The Key Usage X.509 v3 extension defines the purpose of the public key // contained in the certificate. type KeyUsage struct { @@ -948,6 +3495,32 @@ type KeyUsage struct { noSmithyDocumentSerde } +func (v *KeyUsage) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.KeyUsage) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *KeyUsage) SerializeMembers(s smithy.ShapeSerializer) { + if v.Name != "" { + s.WriteString(schemas.KeyUsage_Name, string(v.Name)) + } +} +func (v *KeyUsage) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.KeyUsage, func(s *smithy.Schema) error { + switch s { + case schemas.KeyUsage_Name: + var ev string + if err := d.ReadString(schemas.KeyUsage_Name, &ev); err != nil { + return err + } + v.Name = KeyUsageName(ev) + return nil + } + return nil + }) +} + // Defines a custom ASN.1 X.400 GeneralName using an object identifier (OID) and // value. For more information, see NIST's definition of [Object Identifier (OID)]. // @@ -963,6 +3536,115 @@ type OtherName struct { noSmithyDocumentSerde } +func (v *OtherName) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.OtherName) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *OtherName) SerializeMembers(s smithy.ShapeSerializer) { + if v.ObjectIdentifier != nil { + s.WriteString(schemas.OtherName_ObjectIdentifier, *v.ObjectIdentifier) + } + if v.Value != nil { + s.WriteString(schemas.OtherName_Value, *v.Value) + } +} +func (v *OtherName) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.OtherName, func(s *smithy.Schema) error { + switch s { + case schemas.OtherName_ObjectIdentifier: + v.ObjectIdentifier = new(string) + return d.ReadString(schemas.OtherName_ObjectIdentifier, v.ObjectIdentifier) + case schemas.OtherName_Value: + v.Value = new(string) + return d.ReadString(schemas.OtherName_Value, v.Value) + } + return nil + }) +} + +// Contains details about the prevalidation configuration. +// +// The following types satisfy this interface: +// +// PrevalidationDetailsMemberDnsPrevalidation +type PrevalidationDetails interface { + isPrevalidationDetails() +} + +// DNS-based prevalidation details. +type PrevalidationDetailsMemberDnsPrevalidation struct { + Value DnsPrevalidationDetails + + noSmithyDocumentSerde +} + +func (*PrevalidationDetailsMemberDnsPrevalidation) isPrevalidationDetails() {} +func (v *PrevalidationDetailsMemberDnsPrevalidation) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.PrevalidationDetails_DnsPrevalidation) + v.Value.SerializeMembers(s) + s.CloseStruct() +} +func (v *PrevalidationDetailsMemberDnsPrevalidation) Deserialize(d smithy.ShapeDeserializer) error { + return v.Value.Deserialize(d) +} + +// Specifies prevalidation options for domain validation. +// +// The following types satisfy this interface: +// +// PrevalidationOptionsMemberDnsPrevalidation +type PrevalidationOptions interface { + isPrevalidationOptions() +} + +// DNS-based prevalidation options. +type PrevalidationOptionsMemberDnsPrevalidation struct { + Value DnsPrevalidationOptions + + noSmithyDocumentSerde +} + +func (*PrevalidationOptionsMemberDnsPrevalidation) isPrevalidationOptions() {} +func (v *PrevalidationOptionsMemberDnsPrevalidation) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.PrevalidationOptions_DnsPrevalidation) + v.Value.SerializeMembers(s) + s.CloseStruct() +} +func (v *PrevalidationOptionsMemberDnsPrevalidation) Deserialize(d smithy.ShapeDeserializer) error { + return v.Value.Deserialize(d) +} + +// Configuration for a public certificate authority. +type PublicCertificateAuthority struct { + + // The key algorithms allowed for certificates issued by this certificate + // authority. + AllowedKeyAlgorithms []PublicKeyAlgorithm + + noSmithyDocumentSerde +} + +func (v *PublicCertificateAuthority) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.PublicCertificateAuthority) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *PublicCertificateAuthority) SerializeMembers(s smithy.ShapeSerializer) { + serializePublicKeyAlgorithmList(s, schemas.PublicCertificateAuthority_AllowedKeyAlgorithms, v.AllowedKeyAlgorithms) +} +func (v *PublicCertificateAuthority) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.PublicCertificateAuthority, func(s *smithy.Schema) error { + switch s { + case schemas.PublicCertificateAuthority_AllowedKeyAlgorithms: + return deserializePublicKeyAlgorithmList(d, schemas.PublicCertificateAuthority_AllowedKeyAlgorithms, &v.AllowedKeyAlgorithms) + } + return nil + }) +} + // Contains information about the status of ACM's [managed renewal] for the certificate. This // structure exists only when the certificate type is AMAZON_ISSUED . // @@ -997,6 +3679,51 @@ type RenewalSummary struct { noSmithyDocumentSerde } +func (v *RenewalSummary) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RenewalSummary) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RenewalSummary) SerializeMembers(s smithy.ShapeSerializer) { + serializeDomainValidationList(s, schemas.RenewalSummary_DomainValidationOptions, v.DomainValidationOptions) + if v.RenewalStatus != "" { + s.WriteString(schemas.RenewalSummary_RenewalStatus, string(v.RenewalStatus)) + } + if v.RenewalStatusReason != "" { + s.WriteString(schemas.RenewalSummary_RenewalStatusReason, string(v.RenewalStatusReason)) + } + if v.UpdatedAt != nil { + s.WriteTime(schemas.RenewalSummary_UpdatedAt, *v.UpdatedAt) + } +} +func (v *RenewalSummary) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RenewalSummary, func(s *smithy.Schema) error { + switch s { + case schemas.RenewalSummary_DomainValidationOptions: + return deserializeDomainValidationList(d, schemas.RenewalSummary_DomainValidationOptions, &v.DomainValidationOptions) + case schemas.RenewalSummary_RenewalStatus: + var ev string + if err := d.ReadString(schemas.RenewalSummary_RenewalStatus, &ev); err != nil { + return err + } + v.RenewalStatus = RenewalStatus(ev) + return nil + case schemas.RenewalSummary_RenewalStatusReason: + var ev string + if err := d.ReadString(schemas.RenewalSummary_RenewalStatusReason, &ev); err != nil { + return err + } + v.RenewalStatusReason = FailureReason(ev) + return nil + case schemas.RenewalSummary_UpdatedAt: + v.UpdatedAt = new(time.Time) + return d.ReadTime(schemas.RenewalSummary_UpdatedAt, v.UpdatedAt) + } + return nil + }) +} + // Contains a DNS record value that you can use to validate ownership or control // of a domain. This is used by the DescribeCertificateaction. type ResourceRecord struct { @@ -1020,6 +3747,44 @@ type ResourceRecord struct { noSmithyDocumentSerde } +func (v *ResourceRecord) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ResourceRecord) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ResourceRecord) SerializeMembers(s smithy.ShapeSerializer) { + if v.Name != nil { + s.WriteString(schemas.ResourceRecord_Name, *v.Name) + } + if v.Type != "" { + s.WriteString(schemas.ResourceRecord_Type, string(v.Type)) + } + if v.Value != nil { + s.WriteString(schemas.ResourceRecord_Value, *v.Value) + } +} +func (v *ResourceRecord) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ResourceRecord, func(s *smithy.Schema) error { + switch s { + case schemas.ResourceRecord_Name: + v.Name = new(string) + return d.ReadString(schemas.ResourceRecord_Name, v.Name) + case schemas.ResourceRecord_Type: + var ev string + if err := d.ReadString(schemas.ResourceRecord_Type, &ev); err != nil { + return err + } + v.Type = RecordType(ev) + return nil + case schemas.ResourceRecord_Value: + v.Value = new(string) + return d.ReadString(schemas.ResourceRecord_Value, v.Value) + } + return nil + }) +} + // Filters certificates by subject alternative name attributes. // // The following types satisfy this interface: @@ -1037,6 +3802,14 @@ type SubjectAlternativeNameFilterMemberDnsName struct { } func (*SubjectAlternativeNameFilterMemberDnsName) isSubjectAlternativeNameFilter() {} +func (v *SubjectAlternativeNameFilterMemberDnsName) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.SubjectAlternativeNameFilter_DnsName) + v.Value.SerializeMembers(s) + s.CloseStruct() +} +func (v *SubjectAlternativeNameFilterMemberDnsName) Deserialize(d smithy.ShapeDeserializer) error { + return v.Value.Deserialize(d) +} // Filters certificates by subject attributes. // @@ -1055,6 +3828,14 @@ type SubjectFilterMemberCommonName struct { } func (*SubjectFilterMemberCommonName) isSubjectFilter() {} +func (v *SubjectFilterMemberCommonName) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.SubjectFilter_CommonName) + v.Value.SerializeMembers(s) + s.CloseStruct() +} +func (v *SubjectFilterMemberCommonName) Deserialize(d smithy.ShapeDeserializer) error { + return v.Value.Deserialize(d) +} // A key-value pair that identifies or specifies metadata about an ACM resource. type Tag struct { @@ -1070,6 +3851,34 @@ type Tag struct { noSmithyDocumentSerde } +func (v *Tag) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.Tag) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *Tag) SerializeMembers(s smithy.ShapeSerializer) { + if v.Key != nil { + s.WriteString(schemas.Tag_Key, *v.Key) + } + if v.Value != nil { + s.WriteString(schemas.Tag_Value, *v.Value) + } +} +func (v *Tag) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.Tag, func(s *smithy.Schema) error { + switch s { + case schemas.Tag_Key: + v.Key = new(string) + return d.ReadString(schemas.Tag_Key, v.Key) + case schemas.Tag_Value: + v.Value = new(string) + return d.ReadString(schemas.Tag_Value, v.Value) + } + return nil + }) +} + // A description of why a request was throttled. type ThrottlingReason struct { @@ -1082,6 +3891,34 @@ type ThrottlingReason struct { noSmithyDocumentSerde } +func (v *ThrottlingReason) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ThrottlingReason) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ThrottlingReason) SerializeMembers(s smithy.ShapeSerializer) { + if v.Reason != nil { + s.WriteString(schemas.ThrottlingReason_reason, *v.Reason) + } + if v.Resource != nil { + s.WriteString(schemas.ThrottlingReason_resource, *v.Resource) + } +} +func (v *ThrottlingReason) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ThrottlingReason, func(s *smithy.Schema) error { + switch s { + case schemas.ThrottlingReason_reason: + v.Reason = new(string) + return d.ReadString(schemas.ThrottlingReason_reason, v.Reason) + case schemas.ThrottlingReason_resource: + v.Resource = new(string) + return d.ReadString(schemas.ThrottlingReason_resource, v.Resource) + } + return nil + }) +} + // Specifies a time range for filtering certificates. type TimestampRange struct { @@ -1094,6 +3931,242 @@ type TimestampRange struct { noSmithyDocumentSerde } +func (v *TimestampRange) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.TimestampRange) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *TimestampRange) SerializeMembers(s smithy.ShapeSerializer) { + if v.End != nil { + s.WriteTime(schemas.TimestampRange_End, *v.End) + } + if v.Start != nil { + s.WriteTime(schemas.TimestampRange_Start, *v.Start) + } +} +func (v *TimestampRange) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.TimestampRange, func(s *smithy.Schema) error { + switch s { + case schemas.TimestampRange_End: + v.End = new(time.Time) + return d.ReadTime(schemas.TimestampRange_End, v.End) + case schemas.TimestampRange_Start: + v.Start = new(time.Time) + return d.ReadTime(schemas.TimestampRange_Start, v.Start) + } + return nil + }) +} + +// Contains information about the most recent certificate update, such as a domain +// validation method migration. This structure is returned as part of the CertificateDetailresponse +// from DescribeCertificate. +type UpdateSummary struct { + + // Contains information about a domain validation method migration, including the + // previous and target validation methods. + DomainValidationMethodUpdateSummary *DomainValidationMethodUpdateSummary + + // The time at which the certificate update was requested. + RequestedAt *time.Time + + // The status of the certificate update. The following are valid values: + // + // - PENDING_DOMAIN_VALIDATION – The certificate update is waiting for domain + // ownership validation to complete. + // + // - SUCCESS – The certificate was updated successfully. + // + // - FAILED – The certificate update failed. + Status UpdateStatus + + // The type of update that was requested for the certificate. The following are + // valid values: + // + // - DOMAIN_VALIDATION_METHOD – The update changes the domain validation method + // for the certificate. + Type UpdateType + + // The time at which the certificate update status was last changed. + UpdatedAt *time.Time + + noSmithyDocumentSerde +} + +func (v *UpdateSummary) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.UpdateSummary) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UpdateSummary) SerializeMembers(s smithy.ShapeSerializer) { + if v.DomainValidationMethodUpdateSummary != nil { + s.WriteStruct(schemas.UpdateSummary_DomainValidationMethodUpdateSummary) + v.DomainValidationMethodUpdateSummary.SerializeMembers(s) + s.CloseStruct() + } + if v.RequestedAt != nil { + s.WriteTime(schemas.UpdateSummary_RequestedAt, *v.RequestedAt) + } + if v.Status != "" { + s.WriteString(schemas.UpdateSummary_Status, string(v.Status)) + } + if v.Type != "" { + s.WriteString(schemas.UpdateSummary_Type, string(v.Type)) + } + if v.UpdatedAt != nil { + s.WriteTime(schemas.UpdateSummary_UpdatedAt, *v.UpdatedAt) + } +} +func (v *UpdateSummary) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.UpdateSummary, func(s *smithy.Schema) error { + switch s { + case schemas.UpdateSummary_DomainValidationMethodUpdateSummary: + v.DomainValidationMethodUpdateSummary = &DomainValidationMethodUpdateSummary{} + return v.DomainValidationMethodUpdateSummary.Deserialize(d) + case schemas.UpdateSummary_RequestedAt: + v.RequestedAt = new(time.Time) + return d.ReadTime(schemas.UpdateSummary_RequestedAt, v.RequestedAt) + case schemas.UpdateSummary_Status: + var ev string + if err := d.ReadString(schemas.UpdateSummary_Status, &ev); err != nil { + return err + } + v.Status = UpdateStatus(ev) + return nil + case schemas.UpdateSummary_Type: + var ev string + if err := d.ReadString(schemas.UpdateSummary_Type, &ev); err != nil { + return err + } + v.Type = UpdateType(ev) + return nil + case schemas.UpdateSummary_UpdatedAt: + v.UpdatedAt = new(time.Time) + return d.ReadTime(schemas.UpdateSummary_UpdatedAt, v.UpdatedAt) + } + return nil + }) +} + +// Contains the challenge details that you use to prove domain ownership. Only one +// member is set, depending on the validation method. +// +// The following types satisfy this interface: +// +// ValidationChallengeMemberDnsValidationChallenge +// ValidationChallengeMemberEmailValidationChallenge +type ValidationChallenge interface { + isValidationChallenge() +} + +// Contains the CNAME record that you must add to your DNS configuration to +// validate domain ownership using DNS validation. +type ValidationChallengeMemberDnsValidationChallenge struct { + Value DnsValidationChallenge + + noSmithyDocumentSerde +} + +func (*ValidationChallengeMemberDnsValidationChallenge) isValidationChallenge() {} +func (v *ValidationChallengeMemberDnsValidationChallenge) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ValidationChallenge_DnsValidationChallenge) + v.Value.SerializeMembers(s) + s.CloseStruct() +} +func (v *ValidationChallengeMemberDnsValidationChallenge) Deserialize(d smithy.ShapeDeserializer) error { + return v.Value.Deserialize(d) +} + +// Contains the email addresses used for email-based domain validation. +type ValidationChallengeMemberEmailValidationChallenge struct { + Value EmailValidationChallenge + + noSmithyDocumentSerde +} + +func (*ValidationChallengeMemberEmailValidationChallenge) isValidationChallenge() {} +func (v *ValidationChallengeMemberEmailValidationChallenge) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ValidationChallenge_EmailValidationChallenge) + v.Value.SerializeMembers(s) + s.CloseStruct() +} +func (v *ValidationChallengeMemberEmailValidationChallenge) Deserialize(d smithy.ShapeDeserializer) error { + return v.Value.Deserialize(d) +} + +// Contains the validation method, validation status, and validation challenge +// details for a domain. This structure appears in DomainValidationSummaryas both the active and +// requested validation configuration. +type ValidationConfiguration struct { + + // The validation challenge details for this configuration. The structure varies + // by validation method: for DNS validation, contains a DnsValidationChallenge + // with the CNAME record to add; for email validation, contains an + // EmailValidationChallenge with the validation email addresses. + ValidationChallenge ValidationChallenge + + // The validation method for this configuration. Valid values: + // + // - DNS – Validation using a CNAME record added to your DNS configuration. + // + // - EMAIL – Validation using an approval email sent to domain contacts. + // + // - HTTP – Validation using an HTTP resource placed on your web server. + ValidationMethod ValidationMethod + + // The validation status for this domain. Valid values: + // + // - PENDING_VALIDATION – The domain is waiting for validation to complete. + // + // - SUCCESS – Validation completed successfully. + // + // - FAILED – Validation failed. + ValidationStatus DomainStatus + + noSmithyDocumentSerde +} + +func (v *ValidationConfiguration) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ValidationConfiguration) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ValidationConfiguration) SerializeMembers(s smithy.ShapeSerializer) { + serializeValidationChallenge(s, schemas.ValidationConfiguration_ValidationChallenge, v.ValidationChallenge) + if v.ValidationMethod != "" { + s.WriteString(schemas.ValidationConfiguration_ValidationMethod, string(v.ValidationMethod)) + } + if v.ValidationStatus != "" { + s.WriteString(schemas.ValidationConfiguration_ValidationStatus, string(v.ValidationStatus)) + } +} +func (v *ValidationConfiguration) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ValidationConfiguration, func(s *smithy.Schema) error { + switch s { + case schemas.ValidationConfiguration_ValidationChallenge: + return deserializeValidationChallenge(d, schemas.ValidationConfiguration_ValidationChallenge, &v.ValidationChallenge) + case schemas.ValidationConfiguration_ValidationMethod: + var ev string + if err := d.ReadString(schemas.ValidationConfiguration_ValidationMethod, &ev); err != nil { + return err + } + v.ValidationMethod = ValidationMethod(ev) + return nil + case schemas.ValidationConfiguration_ValidationStatus: + var ev string + if err := d.ReadString(schemas.ValidationConfiguration_ValidationStatus, &ev); err != nil { + return err + } + v.ValidationStatus = DomainStatus(ev) + return nil + } + return nil + }) +} + // Filters certificates by X.509 attributes. // // The following types satisfy this interface: @@ -1118,6 +4191,17 @@ type X509AttributeFilterMemberExtendedKeyUsage struct { } func (*X509AttributeFilterMemberExtendedKeyUsage) isX509AttributeFilter() {} +func (v *X509AttributeFilterMemberExtendedKeyUsage) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.X509AttributeFilter_ExtendedKeyUsage, string(v.Value)) +} +func (v *X509AttributeFilterMemberExtendedKeyUsage) Deserialize(d smithy.ShapeDeserializer) error { + var s string + if err := d.ReadString(schemas.X509AttributeFilter_ExtendedKeyUsage, &s); err != nil { + return err + } + v.Value = ExtendedKeyUsageName(s) + return nil +} // Filter by key algorithm. type X509AttributeFilterMemberKeyAlgorithm struct { @@ -1127,6 +4211,17 @@ type X509AttributeFilterMemberKeyAlgorithm struct { } func (*X509AttributeFilterMemberKeyAlgorithm) isX509AttributeFilter() {} +func (v *X509AttributeFilterMemberKeyAlgorithm) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.X509AttributeFilter_KeyAlgorithm, string(v.Value)) +} +func (v *X509AttributeFilterMemberKeyAlgorithm) Deserialize(d smithy.ShapeDeserializer) error { + var s string + if err := d.ReadString(schemas.X509AttributeFilter_KeyAlgorithm, &s); err != nil { + return err + } + v.Value = KeyAlgorithm(s) + return nil +} // Filter by key usage. type X509AttributeFilterMemberKeyUsage struct { @@ -1136,6 +4231,17 @@ type X509AttributeFilterMemberKeyUsage struct { } func (*X509AttributeFilterMemberKeyUsage) isX509AttributeFilter() {} +func (v *X509AttributeFilterMemberKeyUsage) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.X509AttributeFilter_KeyUsage, string(v.Value)) +} +func (v *X509AttributeFilterMemberKeyUsage) Deserialize(d smithy.ShapeDeserializer) error { + var s string + if err := d.ReadString(schemas.X509AttributeFilter_KeyUsage, &s); err != nil { + return err + } + v.Value = KeyUsageName(s) + return nil +} // Filter by certificate expiration date. The start date is inclusive. type X509AttributeFilterMemberNotAfter struct { @@ -1145,6 +4251,14 @@ type X509AttributeFilterMemberNotAfter struct { } func (*X509AttributeFilterMemberNotAfter) isX509AttributeFilter() {} +func (v *X509AttributeFilterMemberNotAfter) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.X509AttributeFilter_NotAfter) + v.Value.SerializeMembers(s) + s.CloseStruct() +} +func (v *X509AttributeFilterMemberNotAfter) Deserialize(d smithy.ShapeDeserializer) error { + return v.Value.Deserialize(d) +} // Filter by certificate validity start date. The start date is inclusive. type X509AttributeFilterMemberNotBefore struct { @@ -1154,6 +4268,14 @@ type X509AttributeFilterMemberNotBefore struct { } func (*X509AttributeFilterMemberNotBefore) isX509AttributeFilter() {} +func (v *X509AttributeFilterMemberNotBefore) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.X509AttributeFilter_NotBefore) + v.Value.SerializeMembers(s) + s.CloseStruct() +} +func (v *X509AttributeFilterMemberNotBefore) Deserialize(d smithy.ShapeDeserializer) error { + return v.Value.Deserialize(d) +} // Filter by serial number. type X509AttributeFilterMemberSerialNumber struct { @@ -1163,6 +4285,12 @@ type X509AttributeFilterMemberSerialNumber struct { } func (*X509AttributeFilterMemberSerialNumber) isX509AttributeFilter() {} +func (v *X509AttributeFilterMemberSerialNumber) Serialize(s smithy.ShapeSerializer) { + s.WriteString(schemas.X509AttributeFilter_SerialNumber, v.Value) +} +func (v *X509AttributeFilterMemberSerialNumber) Deserialize(d smithy.ShapeDeserializer) error { + return d.ReadString(schemas.X509AttributeFilter_SerialNumber, &v.Value) +} // Filter by certificate subject. type X509AttributeFilterMemberSubject struct { @@ -1172,6 +4300,12 @@ type X509AttributeFilterMemberSubject struct { } func (*X509AttributeFilterMemberSubject) isX509AttributeFilter() {} +func (v *X509AttributeFilterMemberSubject) Serialize(s smithy.ShapeSerializer) { + serializeSubjectFilter(s, schemas.X509AttributeFilter_Subject, v.Value) +} +func (v *X509AttributeFilterMemberSubject) Deserialize(d smithy.ShapeDeserializer) error { + return deserializeSubjectFilter(d, schemas.X509AttributeFilter_Subject, &v.Value) +} // Filter by subject alternative names. type X509AttributeFilterMemberSubjectAlternativeName struct { @@ -1181,6 +4315,12 @@ type X509AttributeFilterMemberSubjectAlternativeName struct { } func (*X509AttributeFilterMemberSubjectAlternativeName) isX509AttributeFilter() {} +func (v *X509AttributeFilterMemberSubjectAlternativeName) Serialize(s smithy.ShapeSerializer) { + serializeSubjectAlternativeNameFilter(s, schemas.X509AttributeFilter_SubjectAlternativeName, v.Value) +} +func (v *X509AttributeFilterMemberSubjectAlternativeName) Deserialize(d smithy.ShapeDeserializer) error { + return deserializeSubjectAlternativeNameFilter(d, schemas.X509AttributeFilter_SubjectAlternativeName, &v.Value) +} // Contains X.509 certificate attributes extracted from the certificate. type X509Attributes struct { @@ -1224,6 +4364,75 @@ type X509Attributes struct { noSmithyDocumentSerde } +func (v *X509Attributes) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.X509Attributes) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *X509Attributes) SerializeMembers(s smithy.ShapeSerializer) { + serializeExtendedKeyUsageNames(s, schemas.X509Attributes_ExtendedKeyUsages, v.ExtendedKeyUsages) + if v.Issuer != nil { + s.WriteStruct(schemas.X509Attributes_Issuer) + v.Issuer.SerializeMembers(s) + s.CloseStruct() + } + if v.KeyAlgorithm != "" { + s.WriteString(schemas.X509Attributes_KeyAlgorithm, string(v.KeyAlgorithm)) + } + serializeKeyUsageNames(s, schemas.X509Attributes_KeyUsages, v.KeyUsages) + if v.NotAfter != nil { + s.WriteTime(schemas.X509Attributes_NotAfter, *v.NotAfter) + } + if v.NotBefore != nil { + s.WriteTime(schemas.X509Attributes_NotBefore, *v.NotBefore) + } + if v.SerialNumber != nil { + s.WriteString(schemas.X509Attributes_SerialNumber, *v.SerialNumber) + } + if v.Subject != nil { + s.WriteStruct(schemas.X509Attributes_Subject) + v.Subject.SerializeMembers(s) + s.CloseStruct() + } + serializeGeneralNameList(s, schemas.X509Attributes_SubjectAlternativeNames, v.SubjectAlternativeNames) +} +func (v *X509Attributes) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.X509Attributes, func(s *smithy.Schema) error { + switch s { + case schemas.X509Attributes_ExtendedKeyUsages: + return deserializeExtendedKeyUsageNames(d, schemas.X509Attributes_ExtendedKeyUsages, &v.ExtendedKeyUsages) + case schemas.X509Attributes_Issuer: + v.Issuer = &DistinguishedName{} + return v.Issuer.Deserialize(d) + case schemas.X509Attributes_KeyAlgorithm: + var ev string + if err := d.ReadString(schemas.X509Attributes_KeyAlgorithm, &ev); err != nil { + return err + } + v.KeyAlgorithm = KeyAlgorithm(ev) + return nil + case schemas.X509Attributes_KeyUsages: + return deserializeKeyUsageNames(d, schemas.X509Attributes_KeyUsages, &v.KeyUsages) + case schemas.X509Attributes_NotAfter: + v.NotAfter = new(time.Time) + return d.ReadTime(schemas.X509Attributes_NotAfter, v.NotAfter) + case schemas.X509Attributes_NotBefore: + v.NotBefore = new(time.Time) + return d.ReadTime(schemas.X509Attributes_NotBefore, v.NotBefore) + case schemas.X509Attributes_SerialNumber: + v.SerialNumber = new(string) + return d.ReadString(schemas.X509Attributes_SerialNumber, v.SerialNumber) + case schemas.X509Attributes_Subject: + v.Subject = &DistinguishedName{} + return v.Subject.Deserialize(d) + case schemas.X509Attributes_SubjectAlternativeNames: + return deserializeGeneralNameList(d, schemas.X509Attributes_SubjectAlternativeNames, &v.SubjectAlternativeNames) + } + return nil + }) +} + type noSmithyDocumentSerde = smithydocument.NoSerde // UnknownUnionMember is returned when a union member is returned over the wire, @@ -1236,10 +4445,14 @@ type UnknownUnionMember struct { } func (*UnknownUnionMember) isAcmCertificateMetadataFilter() {} +func (*UnknownUnionMember) isCertificateAuthority() {} func (*UnknownUnionMember) isCertificateFilter() {} func (*UnknownUnionMember) isCertificateFilterStatement() {} func (*UnknownUnionMember) isCertificateMetadata() {} func (*UnknownUnionMember) isGeneralName() {} +func (*UnknownUnionMember) isPrevalidationDetails() {} +func (*UnknownUnionMember) isPrevalidationOptions() {} func (*UnknownUnionMember) isSubjectAlternativeNameFilter() {} func (*UnknownUnionMember) isSubjectFilter() {} +func (*UnknownUnionMember) isValidationChallenge() {} func (*UnknownUnionMember) isX509AttributeFilter() {} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/validators.go b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/validators.go index 03e208d92..31af1e652 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/acm/validators.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/acm/validators.go @@ -30,6 +30,126 @@ func (m *validateOpAddTagsToCertificate) HandleInitialize(ctx context.Context, i return next.HandleInitialize(ctx, in) } +type validateOpCreateAcmeDomainValidation struct { +} + +func (*validateOpCreateAcmeDomainValidation) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateAcmeDomainValidation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateAcmeDomainValidationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateAcmeDomainValidationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpCreateAcmeEndpoint struct { +} + +func (*validateOpCreateAcmeEndpoint) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateAcmeEndpoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateAcmeEndpointInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateAcmeEndpointInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpCreateAcmeExternalAccountBinding struct { +} + +func (*validateOpCreateAcmeExternalAccountBinding) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateAcmeExternalAccountBinding) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateAcmeExternalAccountBindingInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateAcmeExternalAccountBindingInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpDeleteAcmeDomainValidation struct { +} + +func (*validateOpDeleteAcmeDomainValidation) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteAcmeDomainValidation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteAcmeDomainValidationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteAcmeDomainValidationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpDeleteAcmeEndpoint struct { +} + +func (*validateOpDeleteAcmeEndpoint) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteAcmeEndpoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteAcmeEndpointInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteAcmeEndpointInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpDeleteAcmeExternalAccountBinding struct { +} + +func (*validateOpDeleteAcmeExternalAccountBinding) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteAcmeExternalAccountBinding) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteAcmeExternalAccountBindingInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteAcmeExternalAccountBindingInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDeleteCertificate struct { } @@ -50,6 +170,86 @@ func (m *validateOpDeleteCertificate) HandleInitialize(ctx context.Context, in m return next.HandleInitialize(ctx, in) } +type validateOpDescribeAcmeAccount struct { +} + +func (*validateOpDescribeAcmeAccount) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDescribeAcmeAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DescribeAcmeAccountInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDescribeAcmeAccountInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpDescribeAcmeDomainValidation struct { +} + +func (*validateOpDescribeAcmeDomainValidation) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDescribeAcmeDomainValidation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DescribeAcmeDomainValidationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDescribeAcmeDomainValidationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpDescribeAcmeEndpoint struct { +} + +func (*validateOpDescribeAcmeEndpoint) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDescribeAcmeEndpoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DescribeAcmeEndpointInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDescribeAcmeEndpointInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpDescribeAcmeExternalAccountBinding struct { +} + +func (*validateOpDescribeAcmeExternalAccountBinding) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDescribeAcmeExternalAccountBinding) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DescribeAcmeExternalAccountBindingInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDescribeAcmeExternalAccountBindingInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDescribeCertificate struct { } @@ -90,6 +290,26 @@ func (m *validateOpExportCertificate) HandleInitialize(ctx context.Context, in m return next.HandleInitialize(ctx, in) } +type validateOpGetAcmeExternalAccountBindingCredentials struct { +} + +func (*validateOpGetAcmeExternalAccountBindingCredentials) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpGetAcmeExternalAccountBindingCredentials) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*GetAcmeExternalAccountBindingCredentialsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpGetAcmeExternalAccountBindingCredentialsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpGetCertificate struct { } @@ -130,6 +350,86 @@ func (m *validateOpImportCertificate) HandleInitialize(ctx context.Context, in m return next.HandleInitialize(ctx, in) } +type validateOpListAcmeAccounts struct { +} + +func (*validateOpListAcmeAccounts) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpListAcmeAccounts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ListAcmeAccountsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpListAcmeAccountsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpListAcmeDomainValidations struct { +} + +func (*validateOpListAcmeDomainValidations) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpListAcmeDomainValidations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ListAcmeDomainValidationsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpListAcmeDomainValidationsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpListAcmeExternalAccountBindings struct { +} + +func (*validateOpListAcmeExternalAccountBindings) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpListAcmeExternalAccountBindings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ListAcmeExternalAccountBindingsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpListAcmeExternalAccountBindingsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpListCertificateDomainValidations struct { +} + +func (*validateOpListCertificateDomainValidations) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpListCertificateDomainValidations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ListCertificateDomainValidationsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpListCertificateDomainValidationsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpListTagsForCertificate struct { } @@ -150,6 +450,26 @@ func (m *validateOpListTagsForCertificate) HandleInitialize(ctx context.Context, return next.HandleInitialize(ctx, in) } +type validateOpListTagsForResource struct { +} + +func (*validateOpListTagsForResource) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ListTagsForResourceInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpListTagsForResourceInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpPutAccountConfiguration struct { } @@ -250,54 +570,174 @@ func (m *validateOpResendValidationEmail) HandleInitialize(ctx context.Context, return next.HandleInitialize(ctx, in) } -type validateOpRevokeCertificate struct { +type validateOpRevokeAcmeAccount struct { } -func (*validateOpRevokeCertificate) ID() string { +func (*validateOpRevokeAcmeAccount) ID() string { return "OperationInputValidation" } -func (m *validateOpRevokeCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( +func (m *validateOpRevokeAcmeAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( out middleware.InitializeOutput, metadata middleware.Metadata, err error, ) { - input, ok := in.Parameters.(*RevokeCertificateInput) + input, ok := in.Parameters.(*RevokeAcmeAccountInput) if !ok { return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) } - if err := validateOpRevokeCertificateInput(input); err != nil { + if err := validateOpRevokeAcmeAccountInput(input); err != nil { return out, metadata, err } return next.HandleInitialize(ctx, in) } -type validateOpSearchCertificates struct { +type validateOpRevokeAcmeExternalAccountBinding struct { } -func (*validateOpSearchCertificates) ID() string { +func (*validateOpRevokeAcmeExternalAccountBinding) ID() string { return "OperationInputValidation" } -func (m *validateOpSearchCertificates) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( +func (m *validateOpRevokeAcmeExternalAccountBinding) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( out middleware.InitializeOutput, metadata middleware.Metadata, err error, ) { - input, ok := in.Parameters.(*SearchCertificatesInput) + input, ok := in.Parameters.(*RevokeAcmeExternalAccountBindingInput) if !ok { return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) } - if err := validateOpSearchCertificatesInput(input); err != nil { + if err := validateOpRevokeAcmeExternalAccountBindingInput(input); err != nil { return out, metadata, err } return next.HandleInitialize(ctx, in) } -type validateOpUpdateCertificateOptions struct { +type validateOpRevokeCertificate struct { } -func (*validateOpUpdateCertificateOptions) ID() string { +func (*validateOpRevokeCertificate) ID() string { return "OperationInputValidation" } -func (m *validateOpUpdateCertificateOptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( +func (m *validateOpRevokeCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*RevokeCertificateInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpRevokeCertificateInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpSearchCertificates struct { +} + +func (*validateOpSearchCertificates) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpSearchCertificates) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*SearchCertificatesInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpSearchCertificatesInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpTagResource struct { +} + +func (*validateOpTagResource) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*TagResourceInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpTagResourceInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpUntagResource struct { +} + +func (*validateOpUntagResource) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*UntagResourceInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpUntagResourceInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpUpdateAcmeDomainValidation struct { +} + +func (*validateOpUpdateAcmeDomainValidation) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpUpdateAcmeDomainValidation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*UpdateAcmeDomainValidationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpUpdateAcmeDomainValidationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpUpdateAcmeEndpoint struct { +} + +func (*validateOpUpdateAcmeEndpoint) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpUpdateAcmeEndpoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*UpdateAcmeEndpointInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpUpdateAcmeEndpointInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpUpdateCertificateOptions struct { +} + +func (*validateOpUpdateCertificateOptions) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpUpdateCertificateOptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( out middleware.InitializeOutput, metadata middleware.Metadata, err error, ) { input, ok := in.Parameters.(*UpdateCertificateOptionsInput) @@ -314,10 +754,50 @@ func addOpAddTagsToCertificateValidationMiddleware(stack *middleware.Stack) erro return stack.Initialize.Add(&validateOpAddTagsToCertificate{}, middleware.After) } +func addOpCreateAcmeDomainValidationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateAcmeDomainValidation{}, middleware.After) +} + +func addOpCreateAcmeEndpointValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateAcmeEndpoint{}, middleware.After) +} + +func addOpCreateAcmeExternalAccountBindingValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateAcmeExternalAccountBinding{}, middleware.After) +} + +func addOpDeleteAcmeDomainValidationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteAcmeDomainValidation{}, middleware.After) +} + +func addOpDeleteAcmeEndpointValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteAcmeEndpoint{}, middleware.After) +} + +func addOpDeleteAcmeExternalAccountBindingValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteAcmeExternalAccountBinding{}, middleware.After) +} + func addOpDeleteCertificateValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteCertificate{}, middleware.After) } +func addOpDescribeAcmeAccountValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDescribeAcmeAccount{}, middleware.After) +} + +func addOpDescribeAcmeDomainValidationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDescribeAcmeDomainValidation{}, middleware.After) +} + +func addOpDescribeAcmeEndpointValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDescribeAcmeEndpoint{}, middleware.After) +} + +func addOpDescribeAcmeExternalAccountBindingValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDescribeAcmeExternalAccountBinding{}, middleware.After) +} + func addOpDescribeCertificateValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDescribeCertificate{}, middleware.After) } @@ -326,6 +806,10 @@ func addOpExportCertificateValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpExportCertificate{}, middleware.After) } +func addOpGetAcmeExternalAccountBindingCredentialsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpGetAcmeExternalAccountBindingCredentials{}, middleware.After) +} + func addOpGetCertificateValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpGetCertificate{}, middleware.After) } @@ -334,10 +818,30 @@ func addOpImportCertificateValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpImportCertificate{}, middleware.After) } +func addOpListAcmeAccountsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpListAcmeAccounts{}, middleware.After) +} + +func addOpListAcmeDomainValidationsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpListAcmeDomainValidations{}, middleware.After) +} + +func addOpListAcmeExternalAccountBindingsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpListAcmeExternalAccountBindings{}, middleware.After) +} + +func addOpListCertificateDomainValidationsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpListCertificateDomainValidations{}, middleware.After) +} + func addOpListTagsForCertificateValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpListTagsForCertificate{}, middleware.After) } +func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) +} + func addOpPutAccountConfigurationValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpPutAccountConfiguration{}, middleware.After) } @@ -358,6 +862,14 @@ func addOpResendValidationEmailValidationMiddleware(stack *middleware.Stack) err return stack.Initialize.Add(&validateOpResendValidationEmail{}, middleware.After) } +func addOpRevokeAcmeAccountValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpRevokeAcmeAccount{}, middleware.After) +} + +func addOpRevokeAcmeExternalAccountBindingValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpRevokeAcmeExternalAccountBinding{}, middleware.After) +} + func addOpRevokeCertificateValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpRevokeCertificate{}, middleware.After) } @@ -366,6 +878,22 @@ func addOpSearchCertificatesValidationMiddleware(stack *middleware.Stack) error return stack.Initialize.Add(&validateOpSearchCertificates{}, middleware.After) } +func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) +} + +func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) +} + +func addOpUpdateAcmeDomainValidationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpUpdateAcmeDomainValidation{}, middleware.After) +} + +func addOpUpdateAcmeEndpointValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpUpdateAcmeEndpoint{}, middleware.After) +} + func addOpUpdateCertificateOptionsValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpUpdateCertificateOptions{}, middleware.After) } @@ -440,16 +968,229 @@ func validateCertificateFilterStatementList(v []types.CertificateFilterStatement } } -func validateCommonNameFilter(v *types.CommonNameFilter) error { +func validateCommonNameFilter(v *types.CommonNameFilter) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CommonNameFilter"} + if v.Value == nil { + invalidParams.Add(smithy.NewErrParamRequired("Value")) + } + if len(v.ComparisonOperator) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("ComparisonOperator")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateDnsNameFilter(v *types.DnsNameFilter) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DnsNameFilter"} + if v.Value == nil { + invalidParams.Add(smithy.NewErrParamRequired("Value")) + } + if len(v.ComparisonOperator) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("ComparisonOperator")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateDomainValidationOption(v *types.DomainValidationOption) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DomainValidationOption"} + if v.DomainName == nil { + invalidParams.Add(smithy.NewErrParamRequired("DomainName")) + } + if v.ValidationDomain == nil { + invalidParams.Add(smithy.NewErrParamRequired("ValidationDomain")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateDomainValidationOptionList(v []types.DomainValidationOption) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DomainValidationOptionList"} + for i := range v { + if err := validateDomainValidationOption(&v[i]); err != nil { + invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateExpiration(v *types.Expiration) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "Expiration"} + if v.Value == nil { + invalidParams.Add(smithy.NewErrParamRequired("Value")) + } + if len(v.Type) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("Type")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateSubjectAlternativeNameFilter(v types.SubjectAlternativeNameFilter) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "SubjectAlternativeNameFilter"} + switch uv := v.(type) { + case *types.SubjectAlternativeNameFilterMemberDnsName: + if err := validateDnsNameFilter(&uv.Value); err != nil { + invalidParams.AddNested("[DnsName]", err.(smithy.InvalidParamsError)) + } + + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateSubjectFilter(v types.SubjectFilter) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "SubjectFilter"} + switch uv := v.(type) { + case *types.SubjectFilterMemberCommonName: + if err := validateCommonNameFilter(&uv.Value); err != nil { + invalidParams.AddNested("[CommonName]", err.(smithy.InvalidParamsError)) + } + + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateTag(v *types.Tag) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "Tag"} + if v.Key == nil { + invalidParams.Add(smithy.NewErrParamRequired("Key")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateTagList(v []types.Tag) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "TagList"} + for i := range v { + if err := validateTag(&v[i]); err != nil { + invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateX509AttributeFilter(v types.X509AttributeFilter) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "X509AttributeFilter"} + switch uv := v.(type) { + case *types.X509AttributeFilterMemberSubject: + if err := validateSubjectFilter(uv.Value); err != nil { + invalidParams.AddNested("[Subject]", err.(smithy.InvalidParamsError)) + } + + case *types.X509AttributeFilterMemberSubjectAlternativeName: + if err := validateSubjectAlternativeNameFilter(uv.Value); err != nil { + invalidParams.AddNested("[SubjectAlternativeName]", err.(smithy.InvalidParamsError)) + } + + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpAddTagsToCertificateInput(v *AddTagsToCertificateInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "AddTagsToCertificateInput"} + if v.CertificateArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("CertificateArn")) + } + if v.Tags == nil { + invalidParams.Add(smithy.NewErrParamRequired("Tags")) + } else if v.Tags != nil { + if err := validateTagList(v.Tags); err != nil { + invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpCreateAcmeDomainValidationInput(v *CreateAcmeDomainValidationInput) error { if v == nil { return nil } - invalidParams := smithy.InvalidParamsError{Context: "CommonNameFilter"} - if v.Value == nil { - invalidParams.Add(smithy.NewErrParamRequired("Value")) + invalidParams := smithy.InvalidParamsError{Context: "CreateAcmeDomainValidationInput"} + if v.AcmeEndpointArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeEndpointArn")) } - if len(v.ComparisonOperator) == 0 { - invalidParams.Add(smithy.NewErrParamRequired("ComparisonOperator")) + if v.DomainName == nil { + invalidParams.Add(smithy.NewErrParamRequired("DomainName")) + } + if v.PrevalidationOptions == nil { + invalidParams.Add(smithy.NewErrParamRequired("PrevalidationOptions")) + } + if v.Tags != nil { + if err := validateTagList(v.Tags); err != nil { + invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) + } } if invalidParams.Len() > 0 { return invalidParams @@ -458,16 +1199,26 @@ func validateCommonNameFilter(v *types.CommonNameFilter) error { } } -func validateDnsNameFilter(v *types.DnsNameFilter) error { +func validateOpCreateAcmeEndpointInput(v *CreateAcmeEndpointInput) error { if v == nil { return nil } - invalidParams := smithy.InvalidParamsError{Context: "DnsNameFilter"} - if v.Value == nil { - invalidParams.Add(smithy.NewErrParamRequired("Value")) + invalidParams := smithy.InvalidParamsError{Context: "CreateAcmeEndpointInput"} + if len(v.AuthorizationBehavior) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("AuthorizationBehavior")) } - if len(v.ComparisonOperator) == 0 { - invalidParams.Add(smithy.NewErrParamRequired("ComparisonOperator")) + if v.CertificateAuthority == nil { + invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthority")) + } + if v.Tags != nil { + if err := validateTagList(v.Tags); err != nil { + invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) + } + } + if v.CertificateTags != nil { + if err := validateTagList(v.CertificateTags); err != nil { + invalidParams.AddNested("CertificateTags", err.(smithy.InvalidParamsError)) + } } if invalidParams.Len() > 0 { return invalidParams @@ -476,16 +1227,26 @@ func validateDnsNameFilter(v *types.DnsNameFilter) error { } } -func validateDomainValidationOption(v *types.DomainValidationOption) error { +func validateOpCreateAcmeExternalAccountBindingInput(v *CreateAcmeExternalAccountBindingInput) error { if v == nil { return nil } - invalidParams := smithy.InvalidParamsError{Context: "DomainValidationOption"} - if v.DomainName == nil { - invalidParams.Add(smithy.NewErrParamRequired("DomainName")) + invalidParams := smithy.InvalidParamsError{Context: "CreateAcmeExternalAccountBindingInput"} + if v.AcmeEndpointArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeEndpointArn")) } - if v.ValidationDomain == nil { - invalidParams.Add(smithy.NewErrParamRequired("ValidationDomain")) + if v.RoleArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) + } + if v.Expiration != nil { + if err := validateExpiration(v.Expiration); err != nil { + invalidParams.AddNested("Expiration", err.(smithy.InvalidParamsError)) + } + } + if v.Tags != nil { + if err := validateTagList(v.Tags); err != nil { + invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) + } } if invalidParams.Len() > 0 { return invalidParams @@ -494,15 +1255,13 @@ func validateDomainValidationOption(v *types.DomainValidationOption) error { } } -func validateDomainValidationOptionList(v []types.DomainValidationOption) error { +func validateOpDeleteAcmeDomainValidationInput(v *DeleteAcmeDomainValidationInput) error { if v == nil { return nil } - invalidParams := smithy.InvalidParamsError{Context: "DomainValidationOptionList"} - for i := range v { - if err := validateDomainValidationOption(&v[i]); err != nil { - invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) - } + invalidParams := smithy.InvalidParamsError{Context: "DeleteAcmeDomainValidationInput"} + if v.AcmeDomainValidationArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeDomainValidationArn")) } if invalidParams.Len() > 0 { return invalidParams @@ -511,17 +1270,13 @@ func validateDomainValidationOptionList(v []types.DomainValidationOption) error } } -func validateSubjectAlternativeNameFilter(v types.SubjectAlternativeNameFilter) error { +func validateOpDeleteAcmeEndpointInput(v *DeleteAcmeEndpointInput) error { if v == nil { return nil } - invalidParams := smithy.InvalidParamsError{Context: "SubjectAlternativeNameFilter"} - switch uv := v.(type) { - case *types.SubjectAlternativeNameFilterMemberDnsName: - if err := validateDnsNameFilter(&uv.Value); err != nil { - invalidParams.AddNested("[DnsName]", err.(smithy.InvalidParamsError)) - } - + invalidParams := smithy.InvalidParamsError{Context: "DeleteAcmeEndpointInput"} + if v.AcmeEndpointArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeEndpointArn")) } if invalidParams.Len() > 0 { return invalidParams @@ -530,17 +1285,13 @@ func validateSubjectAlternativeNameFilter(v types.SubjectAlternativeNameFilter) } } -func validateSubjectFilter(v types.SubjectFilter) error { +func validateOpDeleteAcmeExternalAccountBindingInput(v *DeleteAcmeExternalAccountBindingInput) error { if v == nil { return nil } - invalidParams := smithy.InvalidParamsError{Context: "SubjectFilter"} - switch uv := v.(type) { - case *types.SubjectFilterMemberCommonName: - if err := validateCommonNameFilter(&uv.Value); err != nil { - invalidParams.AddNested("[CommonName]", err.(smithy.InvalidParamsError)) - } - + invalidParams := smithy.InvalidParamsError{Context: "DeleteAcmeExternalAccountBindingInput"} + if v.AcmeExternalAccountBindingArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeExternalAccountBindingArn")) } if invalidParams.Len() > 0 { return invalidParams @@ -549,13 +1300,13 @@ func validateSubjectFilter(v types.SubjectFilter) error { } } -func validateTag(v *types.Tag) error { +func validateOpDeleteCertificateInput(v *DeleteCertificateInput) error { if v == nil { return nil } - invalidParams := smithy.InvalidParamsError{Context: "Tag"} - if v.Key == nil { - invalidParams.Add(smithy.NewErrParamRequired("Key")) + invalidParams := smithy.InvalidParamsError{Context: "DeleteCertificateInput"} + if v.CertificateArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("CertificateArn")) } if invalidParams.Len() > 0 { return invalidParams @@ -564,15 +1315,16 @@ func validateTag(v *types.Tag) error { } } -func validateTagList(v []types.Tag) error { +func validateOpDescribeAcmeAccountInput(v *DescribeAcmeAccountInput) error { if v == nil { return nil } - invalidParams := smithy.InvalidParamsError{Context: "TagList"} - for i := range v { - if err := validateTag(&v[i]); err != nil { - invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) - } + invalidParams := smithy.InvalidParamsError{Context: "DescribeAcmeAccountInput"} + if v.AcmeEndpointArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeEndpointArn")) + } + if v.AccountUrl == nil { + invalidParams.Add(smithy.NewErrParamRequired("AccountUrl")) } if invalidParams.Len() > 0 { return invalidParams @@ -581,22 +1333,13 @@ func validateTagList(v []types.Tag) error { } } -func validateX509AttributeFilter(v types.X509AttributeFilter) error { +func validateOpDescribeAcmeDomainValidationInput(v *DescribeAcmeDomainValidationInput) error { if v == nil { return nil } - invalidParams := smithy.InvalidParamsError{Context: "X509AttributeFilter"} - switch uv := v.(type) { - case *types.X509AttributeFilterMemberSubject: - if err := validateSubjectFilter(uv.Value); err != nil { - invalidParams.AddNested("[Subject]", err.(smithy.InvalidParamsError)) - } - - case *types.X509AttributeFilterMemberSubjectAlternativeName: - if err := validateSubjectAlternativeNameFilter(uv.Value); err != nil { - invalidParams.AddNested("[SubjectAlternativeName]", err.(smithy.InvalidParamsError)) - } - + invalidParams := smithy.InvalidParamsError{Context: "DescribeAcmeDomainValidationInput"} + if v.AcmeDomainValidationArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeDomainValidationArn")) } if invalidParams.Len() > 0 { return invalidParams @@ -605,20 +1348,13 @@ func validateX509AttributeFilter(v types.X509AttributeFilter) error { } } -func validateOpAddTagsToCertificateInput(v *AddTagsToCertificateInput) error { +func validateOpDescribeAcmeEndpointInput(v *DescribeAcmeEndpointInput) error { if v == nil { return nil } - invalidParams := smithy.InvalidParamsError{Context: "AddTagsToCertificateInput"} - if v.CertificateArn == nil { - invalidParams.Add(smithy.NewErrParamRequired("CertificateArn")) - } - if v.Tags == nil { - invalidParams.Add(smithy.NewErrParamRequired("Tags")) - } else if v.Tags != nil { - if err := validateTagList(v.Tags); err != nil { - invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) - } + invalidParams := smithy.InvalidParamsError{Context: "DescribeAcmeEndpointInput"} + if v.AcmeEndpointArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeEndpointArn")) } if invalidParams.Len() > 0 { return invalidParams @@ -627,13 +1363,13 @@ func validateOpAddTagsToCertificateInput(v *AddTagsToCertificateInput) error { } } -func validateOpDeleteCertificateInput(v *DeleteCertificateInput) error { +func validateOpDescribeAcmeExternalAccountBindingInput(v *DescribeAcmeExternalAccountBindingInput) error { if v == nil { return nil } - invalidParams := smithy.InvalidParamsError{Context: "DeleteCertificateInput"} - if v.CertificateArn == nil { - invalidParams.Add(smithy.NewErrParamRequired("CertificateArn")) + invalidParams := smithy.InvalidParamsError{Context: "DescribeAcmeExternalAccountBindingInput"} + if v.AcmeExternalAccountBindingArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeExternalAccountBindingArn")) } if invalidParams.Len() > 0 { return invalidParams @@ -675,6 +1411,21 @@ func validateOpExportCertificateInput(v *ExportCertificateInput) error { } } +func validateOpGetAcmeExternalAccountBindingCredentialsInput(v *GetAcmeExternalAccountBindingCredentialsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "GetAcmeExternalAccountBindingCredentialsInput"} + if v.AcmeExternalAccountBindingArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeExternalAccountBindingArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpGetCertificateInput(v *GetCertificateInput) error { if v == nil { return nil @@ -713,6 +1464,66 @@ func validateOpImportCertificateInput(v *ImportCertificateInput) error { } } +func validateOpListAcmeAccountsInput(v *ListAcmeAccountsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ListAcmeAccountsInput"} + if v.AcmeEndpointArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeEndpointArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpListAcmeDomainValidationsInput(v *ListAcmeDomainValidationsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ListAcmeDomainValidationsInput"} + if v.AcmeEndpointArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeEndpointArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpListAcmeExternalAccountBindingsInput(v *ListAcmeExternalAccountBindingsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ListAcmeExternalAccountBindingsInput"} + if v.AcmeEndpointArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeEndpointArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpListCertificateDomainValidationsInput(v *ListCertificateDomainValidationsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ListCertificateDomainValidationsInput"} + if v.CertificateArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("CertificateArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpListTagsForCertificateInput(v *ListTagsForCertificateInput) error { if v == nil { return nil @@ -728,6 +1539,21 @@ func validateOpListTagsForCertificateInput(v *ListTagsForCertificateInput) error } } +func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} + if v.ResourceArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpPutAccountConfigurationInput(v *PutAccountConfigurationInput) error { if v == nil { return nil @@ -826,6 +1652,39 @@ func validateOpResendValidationEmailInput(v *ResendValidationEmailInput) error { } } +func validateOpRevokeAcmeAccountInput(v *RevokeAcmeAccountInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "RevokeAcmeAccountInput"} + if v.AcmeEndpointArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeEndpointArn")) + } + if v.AccountUrl == nil { + invalidParams.Add(smithy.NewErrParamRequired("AccountUrl")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpRevokeAcmeExternalAccountBindingInput(v *RevokeAcmeExternalAccountBindingInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "RevokeAcmeExternalAccountBindingInput"} + if v.AcmeExternalAccountBindingArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeExternalAccountBindingArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpRevokeCertificateInput(v *RevokeCertificateInput) error { if v == nil { return nil @@ -861,6 +1720,76 @@ func validateOpSearchCertificatesInput(v *SearchCertificatesInput) error { } } +func validateOpTagResourceInput(v *TagResourceInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} + if v.ResourceArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) + } + if v.Tags == nil { + invalidParams.Add(smithy.NewErrParamRequired("Tags")) + } else if v.Tags != nil { + if err := validateTagList(v.Tags); err != nil { + invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpUntagResourceInput(v *UntagResourceInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} + if v.ResourceArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) + } + if v.TagKeys == nil { + invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpUpdateAcmeDomainValidationInput(v *UpdateAcmeDomainValidationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "UpdateAcmeDomainValidationInput"} + if v.AcmeDomainValidationArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeDomainValidationArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpUpdateAcmeEndpointInput(v *UpdateAcmeEndpointInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "UpdateAcmeEndpointInput"} + if v.AcmeEndpointArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("AcmeEndpointArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpUpdateCertificateOptionsInput(v *UpdateCertificateOptionsInput) error { if v == nil { return nil diff --git a/vendor/github.com/aws/smithy-go/CHANGELOG.md b/vendor/github.com/aws/smithy-go/CHANGELOG.md index 0d26e973c..8b94da751 100644 --- a/vendor/github.com/aws/smithy-go/CHANGELOG.md +++ b/vendor/github.com/aws/smithy-go/CHANGELOG.md @@ -1,3 +1,53 @@ +# Release (2026-10-21) + +## General Highlights +* **Dependency Update**: Updated to the latest SDK module versions + +## Module Highlights +* `github.com/aws/smithy-go`: v1.28.6 + * **Bug Fix**: Enforce event stream header key value length limit instead of truncating + * **Bug Fix**: Retain the value in a list with the zero value when encountering a null entry on a dense list. This matches how legacy code-generated JSON deserializers behaved. + +# Release (2026-10-09) + +## General Highlights +* **Dependency Update**: Updated to the latest SDK module versions + +## Module Highlights +* `github.com/aws/smithy-go`: v1.28.5 + * **Bug Fix**: Retain the key with the zero value when encountering a null-value key in a dense map. This matches how legacy code-generated JSON deserializers behaved. + +# Release (2026-10-07) + +## General Highlights +* **Dependency Update**: Updated to the latest SDK module versions + +## Module Highlights +* `github.com/aws/smithy-go`: v1.28.4 + * **Bug Fix**: Revert #698 that fixed JoinPath with trailing slash. This has a side effect on certain S3 API paths in the downstream SDK that need more consideration. + +# Release (2026-10-06) + +## General Highlights +* **Dependency Update**: Updated to the latest SDK module versions + +## Module Highlights +* `github.com/aws/smithy-go`: v1.28.3 + * **Bug Fix**: Accept either casing of `message`/`Message` on modeled JSON error structures in schema-based deserialization, and emit the `smithy.api#error` trait in generated schemas + * **Bug Fix**: Include the underlying error when logging failures to discard or close an HTTP response body + +# Release (2026-09-18) + +## General Highlights +* **Dependency Update**: Updated to the latest SDK module versions + +## Module Highlights +* `github.com/aws/smithy-go`: v1.28.2 + * **Bug Fix**: Avoid allocating a slice in ValidateEndpointHost by indexing into the hostname instead of using strings.Split. + * **Bug Fix**: Fix event stream decode panic on unknown header value type. + * **Bug Fix**: Fix schema-serde CBOR decode panic on malformed string/blob length. + * **Bug Fix**: JoinPath keeps a trailing slash when the added path is a slash. + # Release (2026-08-26) ## General Highlights diff --git a/vendor/github.com/aws/smithy-go/Makefile b/vendor/github.com/aws/smithy-go/Makefile index a12b124d5..fb0670f0e 100644 --- a/vendor/github.com/aws/smithy-go/Makefile +++ b/vendor/github.com/aws/smithy-go/Makefile @@ -26,7 +26,7 @@ smithy-publish-local: cd codegen && ./gradlew publishToMavenLocal smithy-build: - cd codegen && ./gradlew build + cd codegen && ./gradlew build --stacktrace smithy-clean: cd codegen && ./gradlew clean diff --git a/vendor/github.com/aws/smithy-go/README.md b/vendor/github.com/aws/smithy-go/README.md index ac5a0a613..28f3d1d5b 100644 --- a/vendor/github.com/aws/smithy-go/README.md +++ b/vendor/github.com/aws/smithy-go/README.md @@ -1,73 +1,52 @@ # Smithy Go -[![Go Build Status](https://github.com/aws/smithy-go/actions/workflows/go.yml/badge.svg?branch=main)](https://github.com/aws/smithy-go/actions/workflows/go.yml)[![Codegen Build Status](https://github.com/aws/smithy-go/actions/workflows/codegen.yml/badge.svg?branch=main)](https://github.com/aws/smithy-go/actions/workflows/codegen.yml) +[![Go Build Status](https://github.com/aws/smithy-go/actions/workflows/go.yml/badge.svg?branch=main)](https://github.com/aws/smithy-go/actions/workflows/go.yml) +[![Codegen Build Status](https://github.com/aws/smithy-go/actions/workflows/codegen.yml/badge.svg?branch=main)](https://github.com/aws/smithy-go/actions/workflows/codegen.yml) +[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE) -[Smithy](https://smithy.io/) code generators for Go and the accompanying smithy-go runtime. +[Smithy](https://smithy.io/) code generators for [Go](https://go.dev/), and +the runtime package the generated code depends on. -The smithy-go runtime requires a minimum version of Go 1.24. +> [!WARNING] +> All interfaces in this repository are subject to change. The client code +> generator in particular powers +> [aws-sdk-go-v2](https://github.com/aws/aws-sdk-go-v2), but arbitrary client +> generation is in an early stage of development: +> * Generated clients are missing certain features that were originally +> implemented SDK-side (e.g. retries) +> * There may be bugs +> * The public APIs of generated clients may be unstable +> +> If you are interested in using the client code generators, we encourage you +> to experiment and share any feedback with us in an issue. -**WARNING: All interfaces are subject to change.** +--- -## :warning: Client codegen is unstable +This repository contains two major components: -The client code generator in this repository powers the aws-sdk-go-v2. -Arbitrary client generation, while possible, is in an early stage of -development: +1. **Codegen** ([`codegen/`](codegen)): A Java/Gradle-based Smithy build + plugin that generates Go client, server, and shape code from Smithy + models. +2. **Runtime** (this module, `github.com/aws/smithy-go`): The Go packages + that code generated by the plugins above depends on. -* Generated clients are missing certain features that were originally - implemented SDK-side (e.g. retries) -* There may be bugs -* The public APIs of generated clients may be unstable +> [!NOTE] +> This repository does not contain any generated clients, such as for S3 or +> other AWS services. Rather, these are the tools that facilitate generating +> those clients (and non-AWS Smithy clients) from a Smithy model. -If you are interested in using the client code generators, we encourage you to -experiment and share any feedback with us in an issue. +## Getting started -## Plugins +If this is your first time using Smithy, follow the +[Smithy Quickstart guide](https://smithy.io/2.0/quickstart.html) to learn the +basics and create a simple Smithy model. -This repository implements the following Smithy build plugins: - -| ID | GAV prefix | Description | -|----|------------|-------------| -| `go-codegen` | `software.amazon.smithy.go:smithy-go-codegen` | Implements Go client code generation for Smithy models. | -| `go-server-codegen` | `software.amazon.smithy.go:smithy-go-codegen` | Implements Go server code generation for Smithy models. | -| `go-shape-codegen` | `software.amazon.smithy.go:smithy-go-codegen` | Implements Go shape code generation (types only) for Smithy models. | - -## `go-codegen` - -### Configuration - -[`GoSettings`](codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen/GoSettings.java) -contains all of the settings enabled from `smithy-build.json` and helper -methods and types. The up-to-date list of top-level properties enabled for -`go-client-codegen` can be found in `GoSettings::from()`. - -| Setting | Type | Required | Description | -|-----------------|---------|----------|-----------------------------------------------------------------------------------------------------------------------------| -| `service` | string | yes | The Shape ID of the service for which to generate the client. | -| `module` | string | yes | Name of the module in `generated.json` (and `go.mod` if `generateGoMod` is enabled) and `doc.go`. | -| `generateGoMod` | boolean | | Whether to generate a default `go.mod` file. The default value is `false`. | -| `goDirective` | string | | [Go directive](https://go.dev/ref/mod#go-mod-file-go) of the module. The default value is the minimum supported Go version. | +The smithy-go runtime requires a minimum version of **Go 1.24**. -### Supported protocols +### Codegen -The protocol a client uses is configured by the `Protocol` field on a client's -`Options`. The SDK will configure a default based on the protocol traits -applied to the modeled service. - -| Protocol | Notes | -|----------|-------| -| [`smithy.protocols#rpcv2Cbor`](https://smithy.io/2.0/additional-specs/protocols/smithy-rpc-v2.html) | | -| [`aws.protocols#restJson1`](https://smithy.io/2.0/aws/protocols/aws-restjson1-protocol.html) | | -| [`aws.protocols#restXml`](https://smithy.io/2.0/aws/protocols/aws-restxml-protocol.html) | | -| [`aws.protocols#awsJson1_0`](https://smithy.io/2.0/aws/protocols/aws-json-1_0-protocol.html) | | -| [`aws.protocols#awsJson1_1`](https://smithy.io/2.0/aws/protocols/aws-json-1_1-protocol.html) | | -| [`aws.protocols#awsQuery`](https://smithy.io/2.0/aws/protocols/aws-query-protocol.html) | | -| [`aws.protocols#ec2Query`](https://smithy.io/2.0/aws/protocols/aws-ec2-query-protocol.html) | | - -### Example - -This example applies the `go-codegen` build plugin to the Smithy quickstart -example created from `smithy init`: +To generate a Go client from a Smithy model, apply the `go-codegen` plugin in +your `smithy-build.json`: ```json { @@ -91,15 +70,136 @@ example created from `smithy init`: } ``` -## `go-server-codegen` +This repository implements the following Smithy build plugins: + +| ID | GAV prefix | Description | +|----|------------|-------------| +| `go-codegen` | `software.amazon.smithy.go:smithy-go-codegen` | Go client code generation for Smithy models. | +| `go-server-codegen` | `software.amazon.smithy.go:smithy-go-codegen` | Go server code generation for Smithy models (work-in-progress, undocumented). | +| `go-shape-codegen` | `software.amazon.smithy.go:smithy-go-codegen` | Go shape code generation (types only) for Smithy models (work-in-progress, undocumented). | -This plugin is a work-in-progress and is currently undocumented. +#### `go-codegen` settings -## `go-shape-codegen` +[`GoSettings`](codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen/GoSettings.java) +contains all of the settings enabled from `smithy-build.json`. The up-to-date +list of top-level properties enabled for `go-codegen` can be found in +`GoSettings::from()`. -This plugin is a work-in-progress and is currently undocumented. +| Setting | Type | Required | Description | +|-----------------|---------|----------|-------------------------------------------------------------------------------------------------------------------------------| +| `service` | string | yes | The Shape ID of the service for which to generate the client. | +| `module` | string | yes | Name of the module in `generated.json` (and `go.mod` if `generateGoMod` is enabled) and `doc.go`. | +| `generateGoMod` | boolean | | Whether to generate a default `go.mod` file. The default value is `false`. | +| `goDirective` | string | | [Go directive](https://go.dev/ref/mod#go-mod-file-go) of the module. The default value is the minimum supported Go version. | + +#### Supported protocols + +The protocol a generated client uses is configured by the `Protocol` field on +the client's `Options`. The SDK configures a default based on the protocol +traits applied to the modeled service. + +Each protocol is implemented as its own package under +[`transport/http/protocol`](transport/http/protocol). Serialization for these +protocols is handled by internal codecs under `protocol/internal` (e.g. +`protocol/internal/json`, `protocol/internal/cbor`, +`protocol/internal/xml`); these largely supersede the top-level +[`encoding/`](encoding) packages of the same name; see +[Encoding](#encoding) below. + +| Protocol | Package | Notes | +|----------|---------|-------| +| [`smithy.protocols#rpcv2Cbor`](https://smithy.io/2.0/additional-specs/protocols/smithy-rpc-v2.html) | [`protocol/rpcv2`](transport/http/protocol/rpcv2) | | +| [`aws.protocols#restJson1`](https://smithy.io/2.0/aws/protocols/aws-restjson1-protocol.html) | [`protocol/restjson1`](transport/http/protocol/restjson1) | | +| [`aws.protocols#restXml`](https://smithy.io/2.0/aws/protocols/aws-restxml-protocol.html) | [`protocol/restxml`](transport/http/protocol/restxml) | | +| [`aws.protocols#awsJson1_0`](https://smithy.io/2.0/aws/protocols/aws-json-1_0-protocol.html) | [`protocol/awsjson`](transport/http/protocol/awsjson) | `awsjson.New10` | +| [`aws.protocols#awsJson1_1`](https://smithy.io/2.0/aws/protocols/aws-json-1_1-protocol.html) | [`protocol/awsjson`](transport/http/protocol/awsjson) | `awsjson.New11` | +| [`aws.protocols#awsQuery`](https://smithy.io/2.0/aws/protocols/aws-query-protocol.html) | [`protocol/awsquery`](transport/http/protocol/awsquery) | | +| [`aws.protocols#ec2Query`](https://smithy.io/2.0/aws/protocols/aws-ec2-query-protocol.html) | [`protocol/ec2query`](transport/http/protocol/ec2query) | | + +These packages are client-only; smithy-go does not currently implement +server-side protocol support. + +Building and testing the codegen plugins is done via Gradle from the +`codegen/` directory: + +```bash +# Build and test codegen +cd codegen && ./gradlew build + +# Publish to local Maven for downstream use +cd codegen && ./gradlew publishToMavenLocal +``` + +See [`codegen/README.md`](codegen/README.md) for local setup instructions. + +## Runtime packages + +All generated clients depend on this module (`github.com/aws/smithy-go`) at +runtime. It also includes a few standalone submodules published separately. + +### Core + +- [`middleware`](middleware): The middleware stack that drives the operation + pipeline. +- [`transport/http`](transport/http): HTTP request/response types and + middleware. +- [`auth`](auth): Auth identity and scheme interfaces. + - [`auth/bearer`](auth/bearer): Bearer token auth. +- [`endpoints`](endpoints): Endpoint resolution types. +- [`context`](context): Context helpers. +- [`logging`](logging): Logging interfaces. +- [`tracing`](tracing): Tracing interfaces. +- [`metrics`](metrics): Metrics interfaces. + +### Encoding + +Wire format encoders/decoders under [`encoding/`](encoding). + +> [!NOTE] +> Most of these packages are effectively legacy. The protocol +> implementations under [`transport/http/protocol`](transport/http/protocol) +> (used by current client codegen) have their own internal codecs under +> `protocol/internal/*` and generally do not build on these packages. +> The `encoding/json`, `encoding/xml`, and `encoding/cbor` packages otherwise +> remain in use by [`document/json`](document/json)/[`document/cbor`](document/cbor) +> and [`eventstream`](eventstream), and by existing generated SDK code that +> predates the newer protocol implementations. + +- [`encoding/json`](encoding/json): JSON encoding/decoding. +- [`encoding/xml`](encoding/xml): XML encoding/decoding. +- [`encoding/cbor`](encoding/cbor): CBOR encoding/decoding (used by + `rpcv2Cbor`). +- [`encoding/httpbinding`](encoding/httpbinding): HTTP binding serde helpers. + +### Document + +- [`document`](document): Smithy document type abstraction. + - [`document/json`](document/json): JSON document codec. + +### Utilities + +- [`container`](container): Generic container types. +- [`io`](io): I/O helpers. +- [`ptr`](ptr): Pointer-to/from-value helpers. +- [`time`](time): Smithy timestamp format helpers. +- [`rand`](rand): UUID/randomness helpers. +- [`testing`](testing): Test assertion helpers for generated protocol tests. + +### Standalone modules + +These are published as separate Go modules, each with its own `go.mod`. + +- [`aws-http-auth`](aws-http-auth): AWS SigV4/SigV4A HTTP signing. +- [`tracing/smithyoteltracing`](tracing/smithyoteltracing): OpenTelemetry + tracing adapter. +- [`metrics/smithyotelmetrics`](metrics/smithyotelmetrics): OpenTelemetry + metrics adapter. + +## Development + +See [CONTRIBUTING](CONTRIBUTING.md) for more information on contributing to +this project, including the changelog process for runtime changes. ## License This project is licensed under the Apache-2.0 License. - diff --git a/vendor/github.com/aws/smithy-go/eventstream/debug.go b/vendor/github.com/aws/smithy-go/eventstream/debug.go index 6049402b1..ca4394f8b 100644 --- a/vendor/github.com/aws/smithy-go/eventstream/debug.go +++ b/vendor/github.com/aws/smithy-go/eventstream/debug.go @@ -139,6 +139,6 @@ func valueFromType(typ valueType, val any) (Value, error) { copy(tv[:], v) return tv, err default: - panic(fmt.Sprintf("unknown type, %s, %T", typ.String(), val)) + return nil, fmt.Errorf("unable to decode unknown type, %s, %T", typ.String(), val) } } diff --git a/vendor/github.com/aws/smithy-go/eventstream/encode.go b/vendor/github.com/aws/smithy-go/eventstream/encode.go index 61cf7238d..f2e37c8b3 100644 --- a/vendor/github.com/aws/smithy-go/eventstream/encode.go +++ b/vendor/github.com/aws/smithy-go/eventstream/encode.go @@ -141,6 +141,13 @@ func encodePrelude(w io.Writer, crc hash.Hash32, headersLen, payloadLen uint32) // stream format. Returns an error if a header fails to encode. func EncodeHeaders(w io.Writer, headers Headers) error { for _, h := range headers { + if len(h.Name) > maxHeaderNameLen { + return LengthError{ + Part: "header name", + Want: maxHeaderNameLen, Have: len(h.Name), + Value: h.Name, + } + } hn := headerName{ Len: uint8(len(h.Name)), } diff --git a/vendor/github.com/aws/smithy-go/eventstream/header.go b/vendor/github.com/aws/smithy-go/eventstream/header.go index f580bda4c..b5aacca00 100644 --- a/vendor/github.com/aws/smithy-go/eventstream/header.go +++ b/vendor/github.com/aws/smithy-go/eventstream/header.go @@ -151,7 +151,7 @@ func decodeHeaderValue(r io.Reader) (Value, error) { err = tv.decode(r) v = tv default: - panic(fmt.Sprintf("unknown value type %d", raw.Type)) + return nil, fmt.Errorf("unable to decode header of unknown value type %d", raw.Type) } // Error could be EOF, let caller deal with it 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 c945a45db..0fbd1dec3 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.28.1" +const goModuleVersion = "1.28.6" diff --git a/vendor/github.com/aws/smithy-go/traits/traits.go b/vendor/github.com/aws/smithy-go/traits/traits.go index 599be4e54..8f5770bec 100644 --- a/vendor/github.com/aws/smithy-go/traits/traits.go +++ b/vendor/github.com/aws/smithy-go/traits/traits.go @@ -10,6 +10,14 @@ type Sensitive struct{} // TraitID identifies the trait. func (*Sensitive) TraitID() smithy.ShapeID { return smithy.ShapeID{Namespace: "smithy.api", Name: "sensitive"} } +// Error represents smithy.api#error. +type Error struct { + Type string +} + +// TraitID identifies the trait. +func (*Error) TraitID() smithy.ShapeID { return smithy.ShapeID{Namespace: "smithy.api", Name: "error"} } + // EventHeader represents smithy.api#eventHeader. type EventHeader struct{} diff --git a/vendor/github.com/aws/smithy-go/transport/http/host.go b/vendor/github.com/aws/smithy-go/transport/http/host.go index b504a455d..b1227bf9e 100644 --- a/vendor/github.com/aws/smithy-go/transport/http/host.go +++ b/vendor/github.com/aws/smithy-go/transport/http/host.go @@ -29,17 +29,23 @@ func ValidateEndpointHost(host string) error { hostname = host } - labels := strings.Split(hostname, ".") - for i, label := range labels { - if i == len(labels)-1 && len(label) == 0 { - // Allow trailing dot for FQDN hosts. - continue + for start := 0; ; { + idx := strings.IndexByte(hostname[start:], '.') + if idx < 0 { + // Last label. Allow it to be empty to permit a trailing dot for + // FQDN hosts. + if label := hostname[start:]; len(label) != 0 && !ValidHostLabel(label) { + errors.WriteString("\nendpoint host domain labels must match \"[a-zA-Z0-9-]{1,63}\", but found: ") + errors.WriteString(label) + } + break } - if !ValidHostLabel(label) { + if label := hostname[start : start+idx]; !ValidHostLabel(label) { errors.WriteString("\nendpoint host domain labels must match \"[a-zA-Z0-9-]{1,63}\", but found: ") errors.WriteString(label) } + start += idx + 1 } if len(hostname) == 0 && len(port) != 0 { diff --git a/vendor/github.com/aws/smithy-go/transport/http/middleware_close_response_body.go b/vendor/github.com/aws/smithy-go/transport/http/middleware_close_response_body.go index a7e70b1cb..247b9bf17 100644 --- a/vendor/github.com/aws/smithy-go/transport/http/middleware_close_response_body.go +++ b/vendor/github.com/aws/smithy-go/transport/http/middleware_close_response_body.go @@ -23,11 +23,11 @@ func CloseResponseBody(ctx context.Context, resp *Response, isStreaming bool, op // Drain to EOF before closing; a body closed while unread prevents // connection reuse. if _, copyErr := io.Copy(io.Discard, resp.Body); copyErr != nil { - middleware.GetLogger(ctx).Logf(logging.Warn, "failed to discard remaining HTTP response body, this may affect connection reuse") + middleware.GetLogger(ctx).Logf(logging.Warn, "failed to discard remaining HTTP response body, this may affect connection reuse: %v", copyErr) } if closeErr := resp.Body.Close(); closeErr != nil { - middleware.GetLogger(ctx).Logf(logging.Warn, "failed to close HTTP response body, this may affect connection reuse") + middleware.GetLogger(ctx).Logf(logging.Warn, "failed to close HTTP response body, this may affect connection reuse: %v", closeErr) } } @@ -95,12 +95,12 @@ func (m *closeResponseBody) HandleDeserialize( // Consume the full body to prevent TCP connection resets on some platforms _, copyErr := io.Copy(io.Discard, resp.Body) if copyErr != nil { - middleware.GetLogger(ctx).Logf(logging.Warn, "failed to discard remaining HTTP response body, this may affect connection reuse") + middleware.GetLogger(ctx).Logf(logging.Warn, "failed to discard remaining HTTP response body, this may affect connection reuse: %v", copyErr) } closeErr := resp.Body.Close() if closeErr != nil { - middleware.GetLogger(ctx).Logf(logging.Warn, "failed to close HTTP response body, this may affect connection reuse") + middleware.GetLogger(ctx).Logf(logging.Warn, "failed to close HTTP response body, this may affect connection reuse: %v", closeErr) } } diff --git a/vendor/github.com/aws/smithy-go/transport/http/protocol/internal/json/shape_deserializer.go b/vendor/github.com/aws/smithy-go/transport/http/protocol/internal/json/shape_deserializer.go index 808c14662..40c277f45 100644 --- a/vendor/github.com/aws/smithy-go/transport/http/protocol/internal/json/shape_deserializer.go +++ b/vendor/github.com/aws/smithy-go/transport/http/protocol/internal/json/shape_deserializer.go @@ -606,7 +606,7 @@ func memberFromToken(s *smithy.Schema, tok []byte, escaped bool) (*smithy.Schema // if the string had no escapes, the raw bytes ARE the unquoted form -- // no point re-trying the lookup if !escaped { - return nil, nil + return errorMessageMember(s, inner), nil } unq, err := unquote(tok) @@ -614,7 +614,29 @@ func memberFromToken(s *smithy.Schema, tok []byte, escaped bool) (*smithy.Schema return nil, err } - return s.Member(unq), nil + if m := s.Member(unq); m != nil { + return m, nil + } + return errorMessageMember(s, []byte(unq)), nil +} + +// Services do not consistently use the casing that is modeled for the message +// part of errors, handle that here. +func errorMessageMember(s *smithy.Schema, name []byte) *smithy.Schema { + var alt string + switch string(name) { + case "message": + alt = "Message" + case "Message": + alt = "message" + default: + return nil + } + + if _, ok := smithy.SchemaTrait[*traits.Error](s); !ok { + return nil + } + return s.Members()[alt] } func isN(tok []byte) bool { return tok[0] == 'n' } diff --git a/vendor/modules.txt b/vendor/modules.txt index 46ea59cd0..a0ae40102 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -33,7 +33,7 @@ github.com/alicebob/miniredis/v2/size # github.com/armon/go-metrics v0.4.1 ## explicit; go 1.12 github.com/armon/go-metrics -# github.com/aws/aws-sdk-go-v2 v1.47.1 +# github.com/aws/aws-sdk-go-v2 v1.47.4 ## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/aws github.com/aws/aws-sdk-go-v2/aws/defaults @@ -78,10 +78,10 @@ github.com/aws/aws-sdk-go-v2/credentials/stscreds ## explicit; go 1.24 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.5.4 +# github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.7 ## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/internal/configsources -# github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.4 +# github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.7 ## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 # github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.4 @@ -89,10 +89,11 @@ github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 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/acm v1.38.3 +# github.com/aws/aws-sdk-go-v2/service/acm v1.50.6 ## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/service/acm github.com/aws/aws-sdk-go-v2/service/acm/internal/endpoints +github.com/aws/aws-sdk-go-v2/service/acm/schemas github.com/aws/aws-sdk-go-v2/service/acm/types # github.com/aws/aws-sdk-go-v2/service/dynamodb v1.69.1 ## explicit; go 1.24 @@ -141,7 +142,7 @@ 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.28.1 +# github.com/aws/smithy-go v1.28.6 ## explicit; go 1.24 github.com/aws/smithy-go github.com/aws/smithy-go/auth