diff --git a/.changelog/0330149b00ce4038bec18bf70638805a.json b/.changelog/0330149b00ce4038bec18bf70638805a.json new file mode 100644 index 00000000000..300e924d4d8 --- /dev/null +++ b/.changelog/0330149b00ce4038bec18bf70638805a.json @@ -0,0 +1,8 @@ +{ + "id": "0330149b-00ce-4038-bec1-8bf70638805a", + "type": "feature", + "description": "Introduced the ability to filter applications by their last assessment date and time and have included metrics for the application's estimated workload Recovery Time Objective (RTO) and estimated workload Recovery Point Objective (RPO).", + "modules": [ + "service/resiliencehub" + ] +} \ No newline at end of file diff --git a/.changelog/16dfbecef7274298ac13e4c131eba717.json b/.changelog/16dfbecef7274298ac13e4c131eba717.json new file mode 100644 index 00000000000..2ffd87709c1 --- /dev/null +++ b/.changelog/16dfbecef7274298ac13e4c131eba717.json @@ -0,0 +1,8 @@ +{ + "id": "16dfbece-f727-4298-ac13-e4c131eba717", + "type": "feature", + "description": "We added a new API action: SendDataSetNotification.", + "modules": [ + "service/dataexchange" + ] +} \ No newline at end of file diff --git a/.changelog/24fcf67c900748d58becf61ca5b78e64.json b/.changelog/24fcf67c900748d58becf61ca5b78e64.json new file mode 100644 index 00000000000..c420cc26514 --- /dev/null +++ b/.changelog/24fcf67c900748d58becf61ca5b78e64.json @@ -0,0 +1,8 @@ +{ + "id": "24fcf67c-9007-48d5-8bec-f61ca5b78e64", + "type": "feature", + "description": "Added support for custom domain names for Amazon Redshift Serverless workgroups. This feature enables customers to create a custom domain name and use ACM to generate fully secure connections to it.", + "modules": [ + "service/redshiftserverless" + ] +} \ No newline at end of file diff --git a/.changelog/5243007b27a6411d92969e25a858f143.json b/.changelog/5243007b27a6411d92969e25a858f143.json new file mode 100644 index 00000000000..fa63c03bac7 --- /dev/null +++ b/.changelog/5243007b27a6411d92969e25a858f143.json @@ -0,0 +1,8 @@ +{ + "id": "5243007b-27a6-411d-9296-9e25a858f143", + "type": "feature", + "description": "Updated ListOutpostsWithS3 API response to include S3OutpostArn for use with AWS RAM.", + "modules": [ + "service/s3outposts" + ] +} \ No newline at end of file diff --git a/.changelog/5c93eb1b55ab4d13af0d001eb650f574.json b/.changelog/5c93eb1b55ab4d13af0d001eb650f574.json new file mode 100644 index 00000000000..eef3a2c6e40 --- /dev/null +++ b/.changelog/5c93eb1b55ab4d13af0d001eb650f574.json @@ -0,0 +1,8 @@ +{ + "id": "5c93eb1b-55ab-4d13-af0d-001eb650f574", + "type": "feature", + "description": "This release adds InstanceId field for phone number APIs.", + "modules": [ + "service/connect" + ] +} \ No newline at end of file diff --git a/.changelog/71325782a3304d13bc1c078f0195ee1a.json b/.changelog/71325782a3304d13bc1c078f0195ee1a.json new file mode 100644 index 00000000000..2bd1eb73912 --- /dev/null +++ b/.changelog/71325782a3304d13bc1c078f0195ee1a.json @@ -0,0 +1,8 @@ +{ + "id": "71325782-a330-4d13-bc1c-078f0195ee1a", + "type": "documentation", + "description": "This release added necessary API documents on creating a Wisdom knowledge base to integrate with S3.", + "modules": [ + "service/wisdom" + ] +} \ No newline at end of file diff --git a/.changelog/ac4b9b6f2b85477b989079cc78d6ce17.json b/.changelog/ac4b9b6f2b85477b989079cc78d6ce17.json new file mode 100644 index 00000000000..44e300edf29 --- /dev/null +++ b/.changelog/ac4b9b6f2b85477b989079cc78d6ce17.json @@ -0,0 +1,8 @@ +{ + "id": "ac4b9b6f-2b85-477b-9890-79cc78d6ce17", + "type": "feature", + "description": "Introducing new API UpdateKxClusterCodeConfiguration, introducing new cache types for clusters and introducing new deployment modes for updating clusters.", + "modules": [ + "service/finspace" + ] +} \ No newline at end of file diff --git a/.changelog/b97c4326a42548e5b48451d4c37f300e.json b/.changelog/b97c4326a42548e5b48451d4c37f300e.json new file mode 100644 index 00000000000..b6c7a08e86b --- /dev/null +++ b/.changelog/b97c4326a42548e5b48451d4c37f300e.json @@ -0,0 +1,8 @@ +{ + "id": "b97c4326-a425-48e5-b484-51d4c37f300e", + "type": "feature", + "description": "Platform version changes to support AL1 deprecation initiative.", + "modules": [ + "service/datasync" + ] +} \ No newline at end of file diff --git a/.changelog/ba30715f538044669076ed9c354a806f.json b/.changelog/ba30715f538044669076ed9c354a806f.json new file mode 100644 index 00000000000..75e8d5c8e9d --- /dev/null +++ b/.changelog/ba30715f538044669076ed9c354a806f.json @@ -0,0 +1,8 @@ +{ + "id": "ba30715f-5380-4466-9076-ed9c354a806f", + "type": "feature", + "description": "This feature allows customers to create a combination of manifest filtering, startover and time delay configuration that applies to all egress requests by default.", + "modules": [ + "service/mediapackagev2" + ] +} \ No newline at end of file diff --git a/.changelog/def961f9913f4a18974b17156f8d60a4.json b/.changelog/def961f9913f4a18974b17156f8d60a4.json new file mode 100644 index 00000000000..f93865915d1 --- /dev/null +++ b/.changelog/def961f9913f4a18974b17156f8d60a4.json @@ -0,0 +1,8 @@ +{ + "id": "def961f9-913f-4a18-974b-17156f8d60a4", + "type": "feature", + "description": "This release launches the CreateIntegration, DeleteIntegration, and DescribeIntegrations APIs to manage zero-ETL Integrations.", + "modules": [ + "service/rds" + ] +} \ No newline at end of file diff --git a/service/connect/api_op_ClaimPhoneNumber.go b/service/connect/api_op_ClaimPhoneNumber.go index 099b9660f1c..0eed348fc5f 100644 --- a/service/connect/api_op_ClaimPhoneNumber.go +++ b/service/connect/api_op_ClaimPhoneNumber.go @@ -61,12 +61,6 @@ type ClaimPhoneNumberInput struct { // This member is required. PhoneNumber *string - // The Amazon Resource Name (ARN) for Amazon Connect instances or traffic - // distribution groups that phone numbers are claimed to. - // - // This member is required. - TargetArn *string - // A unique, case-sensitive identifier that you provide to ensure the idempotency // of the request. If not provided, the Amazon Web Services SDK populates this // field. For more information about idempotency, see Making retries safe with @@ -74,6 +68,12 @@ type ClaimPhoneNumberInput struct { // . Pattern: ^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$ ClientToken *string + // The identifier of the Amazon Connect instance that phone numbers are claimed + // to. You can find the instance ID (https://docs.aws.amazon.com/connect/latest/adminguide/find-instance-arn.html) + // in the Amazon Resource Name (ARN) of the instance. You must enter InstanceId or + // TargetArn . + InstanceId *string + // The description of the phone number. PhoneNumberDescription *string @@ -81,6 +81,11 @@ type ClaimPhoneNumberInput struct { // example, { "tags": {"key1":"value1", "key2":"value2"} }. Tags map[string]string + // The Amazon Resource Name (ARN) for Amazon Connect instances or traffic + // distribution groups that phone number inbound traffic is routed through. You + // must enter InstanceId or TargetArn . + TargetArn *string + noSmithyDocumentSerde } diff --git a/service/connect/api_op_CreateSecurityProfile.go b/service/connect/api_op_CreateSecurityProfile.go index 843acfd006f..638df913fec 100644 --- a/service/connect/api_op_CreateSecurityProfile.go +++ b/service/connect/api_op_CreateSecurityProfile.go @@ -50,7 +50,7 @@ type CreateSecurityProfileInput struct { AllowedAccessControlTags map[string]string // This API is in preview release for Amazon Connect and is subject to change. A - // list of third party applications that the security profile will give access to. + // list of third-party applications that the security profile will give access to. Applications []types.Application // The description of the security profile. diff --git a/service/connect/api_op_ListPhoneNumbersV2.go b/service/connect/api_op_ListPhoneNumbersV2.go index 48b20bc53e2..2493ba24cae 100644 --- a/service/connect/api_op_ListPhoneNumbersV2.go +++ b/service/connect/api_op_ListPhoneNumbersV2.go @@ -43,6 +43,14 @@ func (c *Client) ListPhoneNumbersV2(ctx context.Context, params *ListPhoneNumber type ListPhoneNumbersV2Input struct { + // The identifier of the Amazon Connect instance that phone numbers are claimed + // to. You can find the instance ID (https://docs.aws.amazon.com/connect/latest/adminguide/find-instance-arn.html) + // in the Amazon Resource Name (ARN) of the instance. If both TargetArn and + // InstanceId are not provided, this API lists numbers claimed to all the Amazon + // Connect instances belonging to your account in the same AWS Region as the + // request. + InstanceId *string + // The maximum number of results to return per page. MaxResults *int32 @@ -61,9 +69,10 @@ type ListPhoneNumbersV2Input struct { PhoneNumberTypes []types.PhoneNumberType // The Amazon Resource Name (ARN) for Amazon Connect instances or traffic - // distribution groups that phone numbers are claimed to. If TargetArn input is - // not provided, this API lists numbers claimed to all the Amazon Connect instances - // belonging to your account in the same Amazon Web Services Region as the request. + // distribution groups that phone number inbound traffic is routed through. If both + // TargetArn and InstanceId input are not provided, this API lists numbers claimed + // to all the Amazon Connect instances belonging to your account in the same Amazon + // Web Services Region as the request. TargetArn *string noSmithyDocumentSerde diff --git a/service/connect/api_op_ListSecurityProfileApplications.go b/service/connect/api_op_ListSecurityProfileApplications.go index 79607f2a7b5..3b7efecaae4 100644 --- a/service/connect/api_op_ListSecurityProfileApplications.go +++ b/service/connect/api_op_ListSecurityProfileApplications.go @@ -16,7 +16,7 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Returns a list of third party applications in a specific security profile. +// Returns a list of third-party applications in a specific security profile. func (c *Client) ListSecurityProfileApplications(ctx context.Context, params *ListSecurityProfileApplicationsInput, optFns ...func(*Options)) (*ListSecurityProfileApplicationsOutput, error) { if params == nil { params = &ListSecurityProfileApplicationsInput{} @@ -34,12 +34,13 @@ func (c *Client) ListSecurityProfileApplications(ctx context.Context, params *Li type ListSecurityProfileApplicationsInput struct { - // The instance identifier. + // The identifier of the Amazon Connect instance. You can find the instance ID (https://docs.aws.amazon.com/connect/latest/adminguide/find-instance-arn.html) + // in the Amazon Resource Name (ARN) of the instance. // // This member is required. InstanceId *string - // The security profile identifier. + // The identifier for the security profle. // // This member is required. SecurityProfileId *string @@ -47,9 +48,8 @@ type ListSecurityProfileApplicationsInput struct { // The maximum number of results to return per page. MaxResults *int32 - // The token for the next set of results. The next set of results can be retrieved - // by using the token value returned in the previous response when making the next - // request. + // The token for the next set of results. Use the value returned in the previous + // response in the next request to retrieve the next set of results. NextToken *string noSmithyDocumentSerde @@ -58,12 +58,10 @@ type ListSecurityProfileApplicationsInput struct { type ListSecurityProfileApplicationsOutput struct { // This API is in preview release for Amazon Connect and is subject to change. A - // list of the third party application's metadata. + // list of the third-party application's metadata. Applications []types.Application - // The token for the next set of results. The next set of results can be retrieved - // by using the token value returned in the previous response when making the next - // request. + // If there are additional results, this is the token for the next set of results. NextToken *string // Metadata pertaining to the operation's result. diff --git a/service/connect/api_op_ResumeContactRecording.go b/service/connect/api_op_ResumeContactRecording.go index 66b203e65e7..5dfd38ad38b 100644 --- a/service/connect/api_op_ResumeContactRecording.go +++ b/service/connect/api_op_ResumeContactRecording.go @@ -16,8 +16,10 @@ import ( ) // When a contact is being recorded, and the recording has been suspended using -// SuspendContactRecording, this API resumes recording the call or screen. Voice -// and screen recordings are supported. +// SuspendContactRecording, this API resumes recording whatever recording is +// selected in the flow configuration: call, screen, or both. If only call +// recording or only screen recording is enabled, then it would resume. Voice and +// screen recordings are supported. func (c *Client) ResumeContactRecording(ctx context.Context, params *ResumeContactRecordingInput, optFns ...func(*Options)) (*ResumeContactRecordingOutput, error) { if params == nil { params = &ResumeContactRecordingInput{} diff --git a/service/connect/api_op_SearchAvailablePhoneNumbers.go b/service/connect/api_op_SearchAvailablePhoneNumbers.go index 779d5cb3522..332558cff94 100644 --- a/service/connect/api_op_SearchAvailablePhoneNumbers.go +++ b/service/connect/api_op_SearchAvailablePhoneNumbers.go @@ -47,11 +47,11 @@ type SearchAvailablePhoneNumbersInput struct { // This member is required. PhoneNumberType types.PhoneNumberType - // The Amazon Resource Name (ARN) for Amazon Connect instances or traffic - // distribution groups that phone numbers are claimed to. - // - // This member is required. - TargetArn *string + // The identifier of the Amazon Connect instance that phone numbers are claimed + // to. You can find the instance ID (https://docs.aws.amazon.com/connect/latest/adminguide/find-instance-arn.html) + // in the Amazon Resource Name (ARN) of the instance. You must enter InstanceId or + // TargetArn . + InstanceId *string // The maximum number of results to return per page. MaxResults *int32 @@ -64,6 +64,11 @@ type SearchAvailablePhoneNumbersInput struct { // country code. PhoneNumberPrefix *string + // The Amazon Resource Name (ARN) for Amazon Connect instances or traffic + // distribution groups that phone number inbound traffic is routed through. You + // must enter InstanceId or TargetArn . + TargetArn *string + noSmithyDocumentSerde } diff --git a/service/connect/api_op_SuspendContactRecording.go b/service/connect/api_op_SuspendContactRecording.go index 3ee7849b114..bb288d009dc 100644 --- a/service/connect/api_op_SuspendContactRecording.go +++ b/service/connect/api_op_SuspendContactRecording.go @@ -15,12 +15,14 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// When a contact is being recorded, this API suspends recording the call or -// screen. For example, you might suspend the call or screen recording while -// collecting sensitive information, such as a credit card number. Then use -// ResumeContactRecording to restart recording. The period of time that the -// recording is suspended is filled with silence in the final recording. Voice and -// screen recordings are supported. +// When a contact is being recorded, this API suspends recording whatever is +// selected in the flow configuration: call, screen, or both. If only call +// recording or only screen recording is enabled, then it would be suspended. For +// example, you might suspend the screen recording while collecting sensitive +// information, such as a credit card number. Then use ResumeContactRecording to +// restart recording the screen. The period of time that the recording is suspended +// is filled with silence in the final recording. Voice and screen recordings are +// supported. func (c *Client) SuspendContactRecording(ctx context.Context, params *SuspendContactRecordingInput, optFns ...func(*Options)) (*SuspendContactRecordingOutput, error) { if params == nil { params = &SuspendContactRecordingInput{} diff --git a/service/connect/api_op_UpdatePhoneNumber.go b/service/connect/api_op_UpdatePhoneNumber.go index d2060af95b9..97996072bfb 100644 --- a/service/connect/api_op_UpdatePhoneNumber.go +++ b/service/connect/api_op_UpdatePhoneNumber.go @@ -47,12 +47,6 @@ type UpdatePhoneNumberInput struct { // This member is required. PhoneNumberId *string - // The Amazon Resource Name (ARN) for Amazon Connect instances or traffic - // distribution groups that phone numbers are claimed to. - // - // This member is required. - TargetArn *string - // A unique, case-sensitive identifier that you provide to ensure the idempotency // of the request. If not provided, the Amazon Web Services SDK populates this // field. For more information about idempotency, see Making retries safe with @@ -60,6 +54,17 @@ type UpdatePhoneNumberInput struct { // . ClientToken *string + // The identifier of the Amazon Connect instance that phone numbers are claimed + // to. You can find the instance ID (https://docs.aws.amazon.com/connect/latest/adminguide/find-instance-arn.html) + // in the Amazon Resource Name (ARN) of the instance. You must enter InstanceId or + // TargetArn . + InstanceId *string + + // The Amazon Resource Name (ARN) for Amazon Connect instances or traffic + // distribution groups that phone number inbound traffic is routed through. You + // must enter InstanceId or TargetArn . + TargetArn *string + noSmithyDocumentSerde } diff --git a/service/connect/api_op_UpdateSecurityProfile.go b/service/connect/api_op_UpdateSecurityProfile.go index f4ccfa830d4..2210ed1914f 100644 --- a/service/connect/api_op_UpdateSecurityProfile.go +++ b/service/connect/api_op_UpdateSecurityProfile.go @@ -50,7 +50,7 @@ type UpdateSecurityProfileInput struct { AllowedAccessControlTags map[string]string // This API is in preview release for Amazon Connect and is subject to change. A - // list of the third party application's metadata. + // list of the third-party application's metadata. Applications []types.Application // The description of the security profile. diff --git a/service/connect/deserializers.go b/service/connect/deserializers.go index 3f73ac522da..afdfa7bad25 100644 --- a/service/connect/deserializers.go +++ b/service/connect/deserializers.go @@ -31984,6 +31984,15 @@ func awsRestjson1_deserializeDocumentClaimedPhoneNumberSummary(v **types.Claimed for key, value := range shape { switch key { + case "InstanceId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected InstanceId to be of type string, got %T instead", value) + } + sv.InstanceId = ptr.String(jtv) + } + case "PhoneNumber": if value != nil { jtv, ok := value.(string) @@ -38210,6 +38219,15 @@ func awsRestjson1_deserializeDocumentListPhoneNumbersSummary(v **types.ListPhone for key, value := range shape { switch key { + case "InstanceId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected InstanceId to be of type string, got %T instead", value) + } + sv.InstanceId = ptr.String(jtv) + } + case "PhoneNumber": if value != nil { jtv, ok := value.(string) diff --git a/service/connect/doc.go b/service/connect/doc.go index 8a737d7c98a..e65cb908942 100644 --- a/service/connect/doc.go +++ b/service/connect/doc.go @@ -10,7 +10,7 @@ // efficiently by getting customers in touch with the appropriate agents. There are // limits to the number of Amazon Connect resources that you can create. There are // also limits to the number of requests that you can make per second. For more -// information, seeP98941055 Amazon Connect Service Quotas (https://docs.aws.amazon.com/connect/latest/adminguide/amazon-connect-service-limits.html) +// information, see Amazon Connect Service Quotas (https://docs.aws.amazon.com/connect/latest/adminguide/amazon-connect-service-limits.html) // in the Amazon Connect Administrator Guide. You can connect programmatically to // an Amazon Web Services service by using an endpoint. For a list of Amazon // Connect endpoints, see Amazon Connect Endpoints (https://docs.aws.amazon.com/general/latest/gr/connect_region.html) diff --git a/service/connect/serializers.go b/service/connect/serializers.go index c5b875310c9..48c458aec9b 100644 --- a/service/connect/serializers.go +++ b/service/connect/serializers.go @@ -1212,6 +1212,11 @@ func awsRestjson1_serializeOpDocumentClaimPhoneNumberInput(v *ClaimPhoneNumberIn ok.String(*v.ClientToken) } + if v.InstanceId != nil { + ok := object.Key("InstanceId") + ok.String(*v.InstanceId) + } + if v.PhoneNumber != nil { ok := object.Key("PhoneNumber") ok.String(*v.PhoneNumber) @@ -10205,6 +10210,11 @@ func awsRestjson1_serializeOpDocumentListPhoneNumbersV2Input(v *ListPhoneNumbers object := value.Object() defer object.Close() + if v.InstanceId != nil { + ok := object.Key("InstanceId") + ok.String(*v.InstanceId) + } + if v.MaxResults != nil { ok := object.Key("MaxResults") ok.Integer(*v.MaxResults) @@ -12288,6 +12298,11 @@ func awsRestjson1_serializeOpDocumentSearchAvailablePhoneNumbersInput(v *SearchA object := value.Object() defer object.Close() + if v.InstanceId != nil { + ok := object.Key("InstanceId") + ok.String(*v.InstanceId) + } + if v.MaxResults != nil { ok := object.Key("MaxResults") ok.Integer(*v.MaxResults) @@ -16236,6 +16251,11 @@ func awsRestjson1_serializeOpDocumentUpdatePhoneNumberInput(v *UpdatePhoneNumber ok.String(*v.ClientToken) } + if v.InstanceId != nil { + ok := object.Key("InstanceId") + ok.String(*v.InstanceId) + } + if v.TargetArn != nil { ok := object.Key("TargetArn") ok.String(*v.TargetArn) diff --git a/service/connect/types/types.go b/service/connect/types/types.go index 2f1e2535569..122d22b09b7 100644 --- a/service/connect/types/types.go +++ b/service/connect/types/types.go @@ -148,7 +148,7 @@ type AnswerMachineDetectionConfig struct { } // This API is in preview release for Amazon Connect and is subject to change. A -// third party application's metadata. +// third-party application's metadata. type Application struct { // The permissions that the agent is granted on the application. Only the ACCESS @@ -266,6 +266,11 @@ type ChatStreamingConfiguration struct { // instance or traffic distribution group. type ClaimedPhoneNumberSummary struct { + // The identifier of the Amazon Connect instance that phone numbers are claimed + // to. You can find the instance ID (https://docs.aws.amazon.com/connect/latest/adminguide/find-instance-arn.html) + // in the Amazon Resource Name (ARN) of the instance. + InstanceId *string + // The phone number. Phone numbers are formatted [+] [country code] [subscriber // number including area code] . PhoneNumber *string @@ -312,7 +317,7 @@ type ClaimedPhoneNumberSummary struct { Tags map[string]string // The Amazon Resource Name (ARN) for Amazon Connect instances or traffic - // distribution groups that phone numbers are claimed to. + // distribution groups that phone number inbound traffic is routed through. TargetArn *string noSmithyDocumentSerde @@ -2057,6 +2062,11 @@ type LexV2Bot struct { // instance or traffic distribution group. type ListPhoneNumbersSummary struct { + // The identifier of the Amazon Connect instance that phone numbers are claimed + // to. You can find the instance ID (https://docs.aws.amazon.com/connect/latest/adminguide/find-instance-arn.html) + // in the Amazon Resource Name (ARN) of the instance. + InstanceId *string + // The phone number. Phone numbers are formatted [+] [country code] [subscriber // number including area code] . PhoneNumber *string @@ -2074,7 +2084,7 @@ type ListPhoneNumbersSummary struct { PhoneNumberType PhoneNumberType // The Amazon Resource Name (ARN) for Amazon Connect instances or traffic - // distribution groups that phone numbers are claimed to. + // distribution groups that phone number inbound traffic is routed through. TargetArn *string noSmithyDocumentSerde diff --git a/service/connect/validators.go b/service/connect/validators.go index 339bf2ad2dd..e3cdc0ffad6 100644 --- a/service/connect/validators.go +++ b/service/connect/validators.go @@ -6509,9 +6509,6 @@ func validateOpClaimPhoneNumberInput(v *ClaimPhoneNumberInput) error { return nil } invalidParams := smithy.InvalidParamsError{Context: "ClaimPhoneNumberInput"} - if v.TargetArn == nil { - invalidParams.Add(smithy.NewErrParamRequired("TargetArn")) - } if v.PhoneNumber == nil { invalidParams.Add(smithy.NewErrParamRequired("PhoneNumber")) } @@ -8927,9 +8924,6 @@ func validateOpSearchAvailablePhoneNumbersInput(v *SearchAvailablePhoneNumbersIn return nil } invalidParams := smithy.InvalidParamsError{Context: "SearchAvailablePhoneNumbersInput"} - if v.TargetArn == nil { - invalidParams.Add(smithy.NewErrParamRequired("TargetArn")) - } if len(v.PhoneNumberCountryCode) == 0 { invalidParams.Add(smithy.NewErrParamRequired("PhoneNumberCountryCode")) } @@ -9701,9 +9695,6 @@ func validateOpUpdatePhoneNumberInput(v *UpdatePhoneNumberInput) error { if v.PhoneNumberId == nil { invalidParams.Add(smithy.NewErrParamRequired("PhoneNumberId")) } - if v.TargetArn == nil { - invalidParams.Add(smithy.NewErrParamRequired("TargetArn")) - } if invalidParams.Len() > 0 { return invalidParams } else { diff --git a/service/dataexchange/api_client.go b/service/dataexchange/api_client.go index 14856e032b0..379df2d6863 100644 --- a/service/dataexchange/api_client.go +++ b/service/dataexchange/api_client.go @@ -4,6 +4,7 @@ package dataexchange import ( "context" + cryptorand "crypto/rand" "fmt" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/aws/defaults" @@ -16,6 +17,7 @@ import ( smithydocument "github.com/aws/smithy-go/document" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" + smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" "net" "net/http" @@ -46,6 +48,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + resolveIdempotencyTokenProvider(&options) + for _, fn := range optFns { fn(&options) } @@ -100,6 +104,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 @@ -440,6 +448,13 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func resolveIdempotencyTokenProvider(o *Options) { + if o.IdempotencyTokenProvider != nil { + return + } + o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader) +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, @@ -478,6 +493,11 @@ func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error { return nil } +// IdempotencyTokenProvider interface for providing idempotency token +type IdempotencyTokenProvider interface { + GetIdempotencyToken() (string, error) +} + func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error { return awsmiddleware.AddRequestIDRetrieverMiddleware(stack) } diff --git a/service/dataexchange/api_op_SendDataSetNotification.go b/service/dataexchange/api_op_SendDataSetNotification.go new file mode 100644 index 00000000000..fbf53e454e9 --- /dev/null +++ b/service/dataexchange/api_op_SendDataSetNotification.go @@ -0,0 +1,313 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package dataexchange + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + internalauth "github.com/aws/aws-sdk-go-v2/internal/auth" + "github.com/aws/aws-sdk-go-v2/service/dataexchange/types" + smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// The type of event associated with the data set. +func (c *Client) SendDataSetNotification(ctx context.Context, params *SendDataSetNotificationInput, optFns ...func(*Options)) (*SendDataSetNotificationOutput, error) { + if params == nil { + params = &SendDataSetNotificationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "SendDataSetNotification", params, optFns, c.addOperationSendDataSetNotificationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*SendDataSetNotificationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type SendDataSetNotificationInput struct { + + // Affected data set of the notification. + // + // This member is required. + DataSetId *string + + // The type of the notification. Describing the kind of event the notification is + // alerting you to. + // + // This member is required. + Type types.NotificationType + + // Idempotency key for the notification, this key allows us to deduplicate + // notifications that are sent in quick succession erroneously. + ClientToken *string + + // Free-form text field for providers to add information about their notifications. + Comment *string + + // Extra details specific to this notification type. + Details *types.NotificationDetails + + // Affected scope of this notification such as the underlying resources affected + // by the notification event. + Scope *types.ScopeDetails + + noSmithyDocumentSerde +} + +type SendDataSetNotificationOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationSendDataSetNotificationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsRestjson1_serializeOpSendDataSetNotification{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsRestjson1_deserializeOpSendDataSetNotification{}, middleware.After) + if err != nil { + return err + } + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack, 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 = addSendDataSetNotificationResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addIdempotencyToken_opSendDataSetNotificationMiddleware(stack, options); err != nil { + return err + } + if err = addOpSendDataSetNotificationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSendDataSetNotification(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + return nil +} + +type idempotencyToken_initializeOpSendDataSetNotification struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpSendDataSetNotification) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpSendDataSetNotification) 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.(*SendDataSetNotificationInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *SendDataSetNotificationInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opSendDataSetNotificationMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpSendDataSetNotification{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + +func newServiceMetadataMiddleware_opSendDataSetNotification(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "dataexchange", + OperationName: "SendDataSetNotification", + } +} + +type opSendDataSetNotificationResolveEndpointMiddleware struct { + EndpointResolver EndpointResolverV2 + BuiltInResolver builtInParameterResolver +} + +func (*opSendDataSetNotificationResolveEndpointMiddleware) ID() string { + return "ResolveEndpointV2" +} + +func (m *opSendDataSetNotificationResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if awsmiddleware.GetRequiresLegacyEndpoints(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + if m.EndpointResolver == nil { + return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil") + } + + params := EndpointParameters{} + + m.BuiltInResolver.ResolveBuiltIns(¶ms) + + var resolvedEndpoint smithyendpoints.Endpoint + resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params) + if err != nil { + return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err) + } + + req.URL = &resolvedEndpoint.URI + + for k := range resolvedEndpoint.Headers { + req.Header.Set( + k, + resolvedEndpoint.Headers.Get(k), + ) + } + + authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties) + if err != nil { + var nfe *internalauth.NoAuthenticationSchemesFoundError + if errors.As(err, &nfe) { + // if no auth scheme is found, default to sigv4 + signingName := "dataexchange" + signingRegion := m.BuiltInResolver.(*builtInResolver).Region + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + + } + var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError + if errors.As(err, &ue) { + return out, metadata, fmt.Errorf( + "This operation requests signer version(s) %v but the client only supports %v", + ue.UnsupportedSchemes, + internalauth.SupportedSchemes, + ) + } + } + + for _, authScheme := range authSchemes { + switch authScheme.(type) { + case *internalauth.AuthenticationSchemeV4: + v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4) + var signingName, signingRegion string + if v4Scheme.SigningName == nil { + signingName = "dataexchange" + } else { + signingName = *v4Scheme.SigningName + } + if v4Scheme.SigningRegion == nil { + signingRegion = m.BuiltInResolver.(*builtInResolver).Region + } else { + signingRegion = *v4Scheme.SigningRegion + } + if v4Scheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + break + case *internalauth.AuthenticationSchemeV4A: + v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A) + if v4aScheme.SigningName == nil { + v4aScheme.SigningName = aws.String("dataexchange") + } + if v4aScheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName) + ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0]) + break + case *internalauth.AuthenticationSchemeNone: + break + } + } + + return next.HandleSerialize(ctx, in) +} + +func addSendDataSetNotificationResolveEndpointMiddleware(stack *middleware.Stack, options Options) error { + return stack.Serialize.Insert(&opSendDataSetNotificationResolveEndpointMiddleware{ + EndpointResolver: options.EndpointResolverV2, + BuiltInResolver: &builtInResolver{ + Region: options.Region, + UseDualStack: options.EndpointOptions.UseDualStackEndpoint, + UseFIPS: options.EndpointOptions.UseFIPSEndpoint, + Endpoint: options.BaseEndpoint, + }, + }, "ResolveEndpoint", middleware.After) +} diff --git a/service/dataexchange/deserializers.go b/service/dataexchange/deserializers.go index b54f8d18bed..da83e5ca6c3 100644 --- a/service/dataexchange/deserializers.go +++ b/service/dataexchange/deserializers.go @@ -4063,6 +4063,104 @@ func awsRestjson1_deserializeOpDocumentSendApiAssetOutput(v *SendApiAssetOutput, return nil } +type awsRestjson1_deserializeOpSendDataSetNotification struct { +} + +func (*awsRestjson1_deserializeOpSendDataSetNotification) ID() string { + return "OperationDeserializer" +} + +func (m *awsRestjson1_deserializeOpSendDataSetNotification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsRestjson1_deserializeOpErrorSendDataSetNotification(response, &metadata) + } + output := &SendDataSetNotificationOutput{} + out.Result = output + + return out, metadata, err +} + +func awsRestjson1_deserializeOpErrorSendDataSetNotification(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsRestjson1_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsRestjson1_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsRestjson1_deserializeOpStartJob struct { } diff --git a/service/dataexchange/endpoints.go b/service/dataexchange/endpoints.go index 06e732cc59e..391a592df06 100644 --- a/service/dataexchange/endpoints.go +++ b/service/dataexchange/endpoints.go @@ -410,7 +410,7 @@ func (r *resolver) ResolveEndpoint( } } if _UseFIPS == true { - if true == _PartitionResult.SupportsFIPS { + if _PartitionResult.SupportsFIPS == true { uriString := func() string { var out strings.Builder out.WriteString("https://dataexchange-fips.") diff --git a/service/dataexchange/generated.json b/service/dataexchange/generated.json index 71acb5d5a54..c28602332d4 100644 --- a/service/dataexchange/generated.json +++ b/service/dataexchange/generated.json @@ -31,6 +31,7 @@ "api_op_ListTagsForResource.go", "api_op_RevokeRevision.go", "api_op_SendApiAsset.go", + "api_op_SendDataSetNotification.go", "api_op_StartJob.go", "api_op_TagResource.go", "api_op_UntagResource.go", diff --git a/service/dataexchange/serializers.go b/service/dataexchange/serializers.go index ae244bc3db8..3f810d6c578 100644 --- a/service/dataexchange/serializers.go +++ b/service/dataexchange/serializers.go @@ -11,6 +11,7 @@ import ( "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" smithyhttp "github.com/aws/smithy-go/transport/http" "net/http" "strings" @@ -1709,6 +1710,118 @@ func awsRestjson1_serializeOpHttpBindingsSendApiAssetInput(v *SendApiAssetInput, return nil } +type awsRestjson1_serializeOpSendDataSetNotification struct { +} + +func (*awsRestjson1_serializeOpSendDataSetNotification) ID() string { + return "OperationSerializer" +} + +func (m *awsRestjson1_serializeOpSendDataSetNotification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*SendDataSetNotificationInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + opPath, opQuery := httpbinding.SplitURI("/v1/data-sets/{DataSetId}/notification") + request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) + request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) + request.Method = "POST" + var restEncoder *httpbinding.Encoder + if request.URL.RawPath == "" { + restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + } else { + request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) + restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) + } + + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if err := awsRestjson1_serializeOpHttpBindingsSendDataSetNotificationInput(input, restEncoder); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + restEncoder.SetHeader("Content-Type").String("application/json") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsRestjson1_serializeOpDocumentSendDataSetNotificationInput(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 = restEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} +func awsRestjson1_serializeOpHttpBindingsSendDataSetNotificationInput(v *SendDataSetNotificationInput, encoder *httpbinding.Encoder) error { + if v == nil { + return fmt.Errorf("unsupported serialization of nil %T", v) + } + + if v.DataSetId == nil || len(*v.DataSetId) == 0 { + return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} + } + if v.DataSetId != nil { + if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { + return err + } + } + + return nil +} + +func awsRestjson1_serializeOpDocumentSendDataSetNotificationInput(v *SendDataSetNotificationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ClientToken != nil { + ok := object.Key("ClientToken") + ok.String(*v.ClientToken) + } + + if v.Comment != nil { + ok := object.Key("Comment") + ok.String(*v.Comment) + } + + if v.Details != nil { + ok := object.Key("Details") + if err := awsRestjson1_serializeDocumentNotificationDetails(v.Details, ok); err != nil { + return err + } + } + + if v.Scope != nil { + ok := object.Key("Scope") + if err := awsRestjson1_serializeDocumentScopeDetails(v.Scope, ok); err != nil { + return err + } + } + + if len(v.Type) > 0 { + ok := object.Key("Type") + ok.String(string(v.Type)) + } + + return nil +} + type awsRestjson1_serializeOpStartJob struct { } @@ -2462,6 +2575,30 @@ func awsRestjson1_serializeDocumentDatabaseLFTagPolicyAndPermissions(v *types.Da return nil } +func awsRestjson1_serializeDocumentDataUpdateRequestDetails(v *types.DataUpdateRequestDetails, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.DataUpdatedAt != nil { + ok := object.Key("DataUpdatedAt") + ok.String(smithytime.FormatDateTime(*v.DataUpdatedAt)) + } + + return nil +} + +func awsRestjson1_serializeDocumentDeprecationRequestDetails(v *types.DeprecationRequestDetails, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.DeprecationAt != nil { + ok := object.Key("DeprecationAt") + ok.String(smithytime.FormatDateTime(*v.DeprecationAt)) + } + + return nil +} + func awsRestjson1_serializeDocumentEvent(v *types.Event, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -2752,6 +2889,23 @@ func awsRestjson1_serializeDocumentKmsKeyToGrant(v *types.KmsKeyToGrant, value s return nil } +func awsRestjson1_serializeDocumentLakeFormationTagPolicyDetails(v *types.LakeFormationTagPolicyDetails, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Database != nil { + ok := object.Key("Database") + ok.String(*v.Database) + } + + if v.Table != nil { + ok := object.Key("Table") + ok.String(*v.Table) + } + + return nil +} + func awsRestjson1_serializeDocumentLFTag(v *types.LFTag, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -2832,6 +2986,19 @@ func awsRestjson1_serializeDocumentListOfKmsKeysToGrant(v []types.KmsKeyToGrant, return nil } +func awsRestjson1_serializeDocumentListOfLakeFormationTagPolicies(v []types.LakeFormationTagPolicyDetails, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + if err := awsRestjson1_serializeDocumentLakeFormationTagPolicyDetails(&v[i], av); err != nil { + return err + } + } + return nil +} + func awsRestjson1_serializeDocumentListOfLFTags(v []types.LFTag, value smithyjson.Value) error { array := value.Array() defer array.Close() @@ -2869,6 +3036,19 @@ func awsRestjson1_serializeDocumentListOfRedshiftDataShareAssetSourceEntry(v []t return nil } +func awsRestjson1_serializeDocumentListOfRedshiftDataShares(v []types.RedshiftDataShareDetails, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + if err := awsRestjson1_serializeDocumentRedshiftDataShareDetails(&v[i], av); err != nil { + return err + } + } + return nil +} + func awsRestjson1_serializeDocumentListOfRevisionDestinationEntry(v []types.RevisionDestinationEntry, value smithyjson.Value) error { array := value.Array() defer array.Close() @@ -2882,6 +3062,32 @@ func awsRestjson1_serializeDocumentListOfRevisionDestinationEntry(v []types.Revi return nil } +func awsRestjson1_serializeDocumentListOfS3DataAccesses(v []types.S3DataAccessDetails, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + if err := awsRestjson1_serializeDocumentS3DataAccessDetails(&v[i], av); err != nil { + return err + } + } + return nil +} + +func awsRestjson1_serializeDocumentListOfSchemaChangeDetails(v []types.SchemaChangeDetails, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + if err := awsRestjson1_serializeDocumentSchemaChangeDetails(&v[i], av); err != nil { + return err + } + } + return nil +} + func awsRestjson1_serializeDocumentListOfTableTagPolicyLFPermissions(v []types.TableTagPolicyLFPermission, value smithyjson.Value) error { array := value.Array() defer array.Close() @@ -2904,6 +3110,34 @@ func awsRestjson1_serializeDocumentMapOf__string(v map[string]string, value smit return nil } +func awsRestjson1_serializeDocumentNotificationDetails(v *types.NotificationDetails, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.DataUpdate != nil { + ok := object.Key("DataUpdate") + if err := awsRestjson1_serializeDocumentDataUpdateRequestDetails(v.DataUpdate, ok); err != nil { + return err + } + } + + if v.Deprecation != nil { + ok := object.Key("Deprecation") + if err := awsRestjson1_serializeDocumentDeprecationRequestDetails(v.Deprecation, ok); err != nil { + return err + } + } + + if v.SchemaChange != nil { + ok := object.Key("SchemaChange") + if err := awsRestjson1_serializeDocumentSchemaChangeRequestDetails(v.SchemaChange, ok); err != nil { + return err + } + } + + return nil +} + func awsRestjson1_serializeDocumentRedshiftDataShareAssetSourceEntry(v *types.RedshiftDataShareAssetSourceEntry, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -2916,6 +3150,43 @@ func awsRestjson1_serializeDocumentRedshiftDataShareAssetSourceEntry(v *types.Re return nil } +func awsRestjson1_serializeDocumentRedshiftDataShareDetails(v *types.RedshiftDataShareDetails, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Arn != nil { + ok := object.Key("Arn") + ok.String(*v.Arn) + } + + if v.Database != nil { + ok := object.Key("Database") + ok.String(*v.Database) + } + + if v.Function != nil { + ok := object.Key("Function") + ok.String(*v.Function) + } + + if v.Schema != nil { + ok := object.Key("Schema") + ok.String(*v.Schema) + } + + if v.Table != nil { + ok := object.Key("Table") + ok.String(*v.Table) + } + + if v.View != nil { + ok := object.Key("View") + ok.String(*v.View) + } + + return nil +} + func awsRestjson1_serializeDocumentRequestDetails(v *types.RequestDetails, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -3053,6 +3324,96 @@ func awsRestjson1_serializeDocumentS3DataAccessAssetSourceEntry(v *types.S3DataA return nil } +func awsRestjson1_serializeDocumentS3DataAccessDetails(v *types.S3DataAccessDetails, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.KeyPrefixes != nil { + ok := object.Key("KeyPrefixes") + if err := awsRestjson1_serializeDocumentListOf__string(v.KeyPrefixes, ok); err != nil { + return err + } + } + + if v.Keys != nil { + ok := object.Key("Keys") + if err := awsRestjson1_serializeDocumentListOf__string(v.Keys, ok); err != nil { + return err + } + } + + return nil +} + +func awsRestjson1_serializeDocumentSchemaChangeDetails(v *types.SchemaChangeDetails, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Description != nil { + ok := object.Key("Description") + ok.String(*v.Description) + } + + if v.Name != nil { + ok := object.Key("Name") + ok.String(*v.Name) + } + + if len(v.Type) > 0 { + ok := object.Key("Type") + ok.String(string(v.Type)) + } + + return nil +} + +func awsRestjson1_serializeDocumentSchemaChangeRequestDetails(v *types.SchemaChangeRequestDetails, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Changes != nil { + ok := object.Key("Changes") + if err := awsRestjson1_serializeDocumentListOfSchemaChangeDetails(v.Changes, ok); err != nil { + return err + } + } + + if v.SchemaChangeAt != nil { + ok := object.Key("SchemaChangeAt") + ok.String(smithytime.FormatDateTime(*v.SchemaChangeAt)) + } + + return nil +} + +func awsRestjson1_serializeDocumentScopeDetails(v *types.ScopeDetails, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.LakeFormationTagPolicies != nil { + ok := object.Key("LakeFormationTagPolicies") + if err := awsRestjson1_serializeDocumentListOfLakeFormationTagPolicies(v.LakeFormationTagPolicies, ok); err != nil { + return err + } + } + + if v.RedshiftDataShares != nil { + ok := object.Key("RedshiftDataShares") + if err := awsRestjson1_serializeDocumentListOfRedshiftDataShares(v.RedshiftDataShares, ok); err != nil { + return err + } + } + + if v.S3DataAccesses != nil { + ok := object.Key("S3DataAccesses") + if err := awsRestjson1_serializeDocumentListOfS3DataAccesses(v.S3DataAccesses, ok); err != nil { + return err + } + } + + return nil +} + func awsRestjson1_serializeDocumentTableLFTagPolicyAndPermissions(v *types.TableLFTagPolicyAndPermissions, value smithyjson.Value) error { object := value.Object() defer object.Close() diff --git a/service/dataexchange/types/enums.go b/service/dataexchange/types/enums.go index 24938c1bb1c..ba827b7ea5d 100644 --- a/service/dataexchange/types/enums.go +++ b/service/dataexchange/types/enums.go @@ -256,6 +256,28 @@ func (LimitName) Values() []LimitName { } } +type NotificationType string + +// Enum values for NotificationType +const ( + NotificationTypeDataDelay NotificationType = "DATA_DELAY" + NotificationTypeDataUpdate NotificationType = "DATA_UPDATE" + NotificationTypeDeprecation NotificationType = "DEPRECATION" + NotificationTypeSchemaChange NotificationType = "SCHEMA_CHANGE" +) + +// Values returns all known values for NotificationType. 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 (NotificationType) Values() []NotificationType { + return []NotificationType{ + "DATA_DELAY", + "DATA_UPDATE", + "DEPRECATION", + "SCHEMA_CHANGE", + } +} + type Origin string // Enum values for Origin @@ -314,6 +336,26 @@ func (ResourceType) Values() []ResourceType { } } +type SchemaChangeType string + +// Enum values for SchemaChangeType +const ( + SchemaChangeTypeAdd SchemaChangeType = "ADD" + SchemaChangeTypeRemove SchemaChangeType = "REMOVE" + SchemaChangeTypeModify SchemaChangeType = "MODIFY" +) + +// Values returns all known values for SchemaChangeType. 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 (SchemaChangeType) Values() []SchemaChangeType { + return []SchemaChangeType{ + "ADD", + "REMOVE", + "MODIFY", + } +} + type ServerSideEncryptionTypes string // Enum values for ServerSideEncryptionTypes diff --git a/service/dataexchange/types/types.go b/service/dataexchange/types/types.go index d9e28eb08b6..cb60a007f1a 100644 --- a/service/dataexchange/types/types.go +++ b/service/dataexchange/types/types.go @@ -335,6 +335,27 @@ type DataSetEntry struct { noSmithyDocumentSerde } +// Extra details specific to a data update type notification. +type DataUpdateRequestDetails struct { + + // A datetime in the past when the data was updated. This typically means that the + // underlying resource supporting the data set was updated. + DataUpdatedAt *time.Time + + noSmithyDocumentSerde +} + +// Extra details specific to a deprecation type notification. +type DeprecationRequestDetails struct { + + // A datetime in the future when the data set will be deprecated. + // + // This member is required. + DeprecationAt *time.Time + + noSmithyDocumentSerde +} + // Information about the job error. type Details struct { @@ -1003,6 +1024,18 @@ type LakeFormationDataPermissionDetails struct { noSmithyDocumentSerde } +// Extra details specific to the affected scope in this LF data set. +type LakeFormationTagPolicyDetails struct { + + // The underlying Glue database that the notification is referring to. + Database *string + + // The underlying Glue table that the notification is referring to. + Table *string + + noSmithyDocumentSerde +} + // Details about the AWS Lake Formation resource (Table or Database) included in // the AWS Lake Formation data permission. type LFResourceDetails struct { @@ -1055,6 +1088,21 @@ type LFTagPolicyDetails struct { noSmithyDocumentSerde } +// Extra details specific to this notification. +type NotificationDetails struct { + + // Extra details specific to a data update type notification. + DataUpdate *DataUpdateRequestDetails + + // Extra details specific to a deprecation type notification. + Deprecation *DeprecationRequestDetails + + // Extra details specific to a schema change type notification. + SchemaChange *SchemaChangeRequestDetails + + noSmithyDocumentSerde +} + // Details about the origin of the data set. type OriginDetails struct { @@ -1088,6 +1136,40 @@ type RedshiftDataShareAssetSourceEntry struct { noSmithyDocumentSerde } +// Extra details specific to the affected scope in this Redshift data set. +type RedshiftDataShareDetails struct { + + // The ARN of the underlying Redshift data share that is being affected by this + // notification. + // + // This member is required. + Arn *string + + // The database name in the Redshift data share that is being affected by this + // notification. + // + // This member is required. + Database *string + + // A function name in the Redshift database that is being affected by this + // notification. + Function *string + + // A schema name in the Redshift database that is being affected by this + // notification. + Schema *string + + // A table name in the Redshift database that is being affected by this + // notification. + Table *string + + // A view name in the Redshift database that is being affected by this + // notification. + View *string + + noSmithyDocumentSerde +} + // The details for the request. type RequestDetails struct { @@ -1296,6 +1378,20 @@ type S3DataAccessAssetSourceEntry struct { noSmithyDocumentSerde } +// Extra details specific to the affected scope in this S3 Data Access data set. +type S3DataAccessDetails struct { + + // A list of the key prefixes affected by this notification. This can have up to + // 50 entries. + KeyPrefixes []string + + // A list of the keys affected by this notification. This can have up to 50 + // entries. + Keys []string + + noSmithyDocumentSerde +} + // The Amazon S3 object that is the asset. type S3SnapshotAsset struct { @@ -1307,6 +1403,57 @@ type S3SnapshotAsset struct { noSmithyDocumentSerde } +// Object encompassing information about a schema change to a single, particular +// field, a notification can have up to 100 of these. +type SchemaChangeDetails struct { + + // Name of the changing field. This value can be up to 255 characters long. + // + // This member is required. + Name *string + + // Is the field being added, removed, or modified? + // + // This member is required. + Type SchemaChangeType + + // Description of what's changing about this field. This value can be up to 512 + // characters long. + Description *string + + noSmithyDocumentSerde +} + +// Extra details specific to this schema change type notification. +type SchemaChangeRequestDetails struct { + + // A date in the future when the schema change is taking effect. + // + // This member is required. + SchemaChangeAt *time.Time + + // List of schema changes happening in the scope of this notification. This can + // have up to 100 entries. + Changes []SchemaChangeDetails + + noSmithyDocumentSerde +} + +// Details about the scope of the notifications such as the affected resources. +type ScopeDetails struct { + + // Underlying LF resources that will be affected by this notification. + LakeFormationTagPolicies []LakeFormationTagPolicyDetails + + // Underlying Redshift resources that will be affected by this notification. + RedshiftDataShares []RedshiftDataShareDetails + + // Underlying S3 resources that will be affected by this notification. + S3DataAccesses []S3DataAccessDetails + + noSmithyDocumentSerde +} + // The LF-tag policy for a table resource. type TableLFTagPolicy struct { diff --git a/service/dataexchange/validators.go b/service/dataexchange/validators.go index 1158f211205..6159f926053 100644 --- a/service/dataexchange/validators.go +++ b/service/dataexchange/validators.go @@ -390,6 +390,26 @@ func (m *validateOpSendApiAsset) HandleInitialize(ctx context.Context, in middle return next.HandleInitialize(ctx, in) } +type validateOpSendDataSetNotification struct { +} + +func (*validateOpSendDataSetNotification) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpSendDataSetNotification) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*SendDataSetNotificationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpSendDataSetNotificationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpStartJob struct { } @@ -606,6 +626,10 @@ func addOpSendApiAssetValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpSendApiAsset{}, middleware.After) } +func addOpSendDataSetNotificationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpSendDataSetNotification{}, middleware.After) +} + func addOpStartJobValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpStartJob{}, middleware.After) } @@ -773,6 +797,21 @@ func validateDatabaseLFTagPolicyAndPermissions(v *types.DatabaseLFTagPolicyAndPe } } +func validateDeprecationRequestDetails(v *types.DeprecationRequestDetails) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DeprecationRequestDetails"} + if v.DeprecationAt == nil { + invalidParams.Add(smithy.NewErrParamRequired("DeprecationAt")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateEvent(v *types.Event) error { if v == nil { return nil @@ -1142,6 +1181,23 @@ func validateListOfRedshiftDataShareAssetSourceEntry(v []types.RedshiftDataShare } } +func validateListOfRedshiftDataShares(v []types.RedshiftDataShareDetails) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ListOfRedshiftDataShares"} + for i := range v { + if err := validateRedshiftDataShareDetails(&v[i]); err != nil { + invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateListOfRevisionDestinationEntry(v []types.RevisionDestinationEntry) error { if v == nil { return nil @@ -1159,6 +1215,45 @@ func validateListOfRevisionDestinationEntry(v []types.RevisionDestinationEntry) } } +func validateListOfSchemaChangeDetails(v []types.SchemaChangeDetails) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ListOfSchemaChangeDetails"} + for i := range v { + if err := validateSchemaChangeDetails(&v[i]); err != nil { + invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateNotificationDetails(v *types.NotificationDetails) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "NotificationDetails"} + if v.Deprecation != nil { + if err := validateDeprecationRequestDetails(v.Deprecation); err != nil { + invalidParams.AddNested("Deprecation", err.(smithy.InvalidParamsError)) + } + } + if v.SchemaChange != nil { + if err := validateSchemaChangeRequestDetails(v.SchemaChange); err != nil { + invalidParams.AddNested("SchemaChange", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateRedshiftDataShareAssetSourceEntry(v *types.RedshiftDataShareAssetSourceEntry) error { if v == nil { return nil @@ -1174,6 +1269,24 @@ func validateRedshiftDataShareAssetSourceEntry(v *types.RedshiftDataShareAssetSo } } +func validateRedshiftDataShareDetails(v *types.RedshiftDataShareDetails) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "RedshiftDataShareDetails"} + if v.Arn == nil { + invalidParams.Add(smithy.NewErrParamRequired("Arn")) + } + if v.Database == nil { + invalidParams.Add(smithy.NewErrParamRequired("Database")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateRequestDetails(v *types.RequestDetails) error { if v == nil { return nil @@ -1284,6 +1397,61 @@ func validateS3DataAccessAssetSourceEntry(v *types.S3DataAccessAssetSourceEntry) } } +func validateSchemaChangeDetails(v *types.SchemaChangeDetails) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "SchemaChangeDetails"} + if v.Name == nil { + invalidParams.Add(smithy.NewErrParamRequired("Name")) + } + if len(v.Type) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("Type")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateSchemaChangeRequestDetails(v *types.SchemaChangeRequestDetails) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "SchemaChangeRequestDetails"} + if v.Changes != nil { + if err := validateListOfSchemaChangeDetails(v.Changes); err != nil { + invalidParams.AddNested("Changes", err.(smithy.InvalidParamsError)) + } + } + if v.SchemaChangeAt == nil { + invalidParams.Add(smithy.NewErrParamRequired("SchemaChangeAt")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateScopeDetails(v *types.ScopeDetails) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ScopeDetails"} + if v.RedshiftDataShares != nil { + if err := validateListOfRedshiftDataShares(v.RedshiftDataShares); err != nil { + invalidParams.AddNested("RedshiftDataShares", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateTableLFTagPolicyAndPermissions(v *types.TableLFTagPolicyAndPermissions) error { if v == nil { return nil @@ -1648,6 +1816,34 @@ func validateOpSendApiAssetInput(v *SendApiAssetInput) error { } } +func validateOpSendDataSetNotificationInput(v *SendDataSetNotificationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "SendDataSetNotificationInput"} + if v.Scope != nil { + if err := validateScopeDetails(v.Scope); err != nil { + invalidParams.AddNested("Scope", err.(smithy.InvalidParamsError)) + } + } + if v.DataSetId == nil { + invalidParams.Add(smithy.NewErrParamRequired("DataSetId")) + } + if v.Details != nil { + if err := validateNotificationDetails(v.Details); err != nil { + invalidParams.AddNested("Details", err.(smithy.InvalidParamsError)) + } + } + if len(v.Type) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("Type")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpStartJobInput(v *StartJobInput) error { if v == nil { return nil diff --git a/service/datasync/api_op_CreateLocationFsxOntap.go b/service/datasync/api_op_CreateLocationFsxOntap.go index 4763f943511..d9d99b38926 100644 --- a/service/datasync/api_op_CreateLocationFsxOntap.go +++ b/service/datasync/api_op_CreateLocationFsxOntap.go @@ -17,8 +17,8 @@ import ( ) // Creates an endpoint for an Amazon FSx for NetApp ONTAP file system that -// DataSync can access for a transfer. For more information, see Creating a -// location for FSx for ONTAP (https://docs.aws.amazon.com/datasync/latest/userguide/create-ontap-location.html) +// DataSync can use for a data transfer. Before you begin, make sure that you +// understand how DataSync accesses an FSx for ONTAP file system (https://docs.aws.amazon.com/datasync/latest/userguide/create-ontap-location.html#create-ontap-location-access) // . func (c *Client) CreateLocationFsxOntap(ctx context.Context, params *CreateLocationFsxOntapInput, optFns ...func(*Options)) (*CreateLocationFsxOntapOutput, error) { if params == nil { diff --git a/service/datasync/api_op_CreateLocationFsxWindows.go b/service/datasync/api_op_CreateLocationFsxWindows.go index ab72e4ef382..200a3eb6621 100644 --- a/service/datasync/api_op_CreateLocationFsxWindows.go +++ b/service/datasync/api_op_CreateLocationFsxWindows.go @@ -16,7 +16,10 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Creates an endpoint for an Amazon FSx for Windows File Server file system. +// Creates an endpoint for an Amazon FSx for Windows File Server file system that +// DataSync can use for a data transfer. Before you begin, make sure that you +// understand how DataSync accesses an FSx for Windows File Server (https://docs.aws.amazon.com/datasync/latest/userguide/create-fsx-location.html#create-fsx-location-access) +// . func (c *Client) CreateLocationFsxWindows(ctx context.Context, params *CreateLocationFsxWindowsInput, optFns ...func(*Options)) (*CreateLocationFsxWindowsOutput, error) { if params == nil { params = &CreateLocationFsxWindowsInput{} @@ -41,7 +44,8 @@ type CreateLocationFsxWindowsInput struct { FsxFilesystemArn *string // Specifies the password of the user who has the permissions to access files and - // folders in the file system. + // folders in the file system. For more information, see required permissions (https://docs.aws.amazon.com/datasync/latest/userguide/create-fsx-location.html#create-fsx-windows-location-permissions) + // for FSx for Windows File Server locations. // // This member is required. Password *string @@ -57,15 +61,18 @@ type CreateLocationFsxWindowsInput struct { SecurityGroupArns []string // Specifies the user who has the permissions to access files, folders, and - // metadata in your file system. For information about choosing a user with - // sufficient permissions, see Required permissions (https://docs.aws.amazon.com/datasync/latest/userguide/create-fsx-location.html#create-fsx-windows-location-permissions) - // . + // metadata in your file system. For information about choosing a user with the + // right level of access for your transfer, see required permissions (https://docs.aws.amazon.com/datasync/latest/userguide/create-fsx-location.html#create-fsx-windows-location-permissions) + // for FSx for Windows File Server locations. // // This member is required. User *string // Specifies the name of the Windows domain that the FSx for Windows File Server - // belongs to. + // belongs to. If you have multiple domains in your environment, configuring this + // parameter makes sure that DataSync connects to the right file server. For more + // information, see required permissions (https://docs.aws.amazon.com/datasync/latest/userguide/create-fsx-location.html#create-fsx-windows-location-permissions) + // for FSx for Windows File Server locations. Domain *string // Specifies a mount path for your file system using forward slashes. This is diff --git a/service/datasync/api_op_CreateLocationSmb.go b/service/datasync/api_op_CreateLocationSmb.go index 3feea62a882..190bde03bed 100644 --- a/service/datasync/api_op_CreateLocationSmb.go +++ b/service/datasync/api_op_CreateLocationSmb.go @@ -79,8 +79,10 @@ type CreateLocationSmbInput struct { // This member is required. User *string - // Specifies the Windows domain name that your SMB file server belongs to. For - // more information, see required permissions (https://docs.aws.amazon.com/datasync/latest/userguide/create-smb-location.html#configuring-smb-permissions) + // Specifies the Windows domain name that your SMB file server belongs to. If you + // have multiple domains in your environment, configuring this parameter makes sure + // that DataSync connects to the right file server. For more information, see + // required permissions (https://docs.aws.amazon.com/datasync/latest/userguide/create-smb-location.html#configuring-smb-permissions) // for SMB locations. Domain *string diff --git a/service/datasync/api_op_DeleteAgent.go b/service/datasync/api_op_DeleteAgent.go index b55b29c8d6a..83d714cbe5e 100644 --- a/service/datasync/api_op_DeleteAgent.go +++ b/service/datasync/api_op_DeleteAgent.go @@ -15,10 +15,12 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Deletes an agent. To specify which agent to delete, use the Amazon Resource -// Name (ARN) of the agent in your request. The operation disassociates the agent -// from your Amazon Web Services account. However, it doesn't delete the agent -// virtual machine (VM) from your on-premises environment. +// Removes an DataSync agent resource from your Amazon Web Services account. Keep +// in mind that this operation (which can't be undone) doesn't remove the agent's +// virtual machine (VM) or Amazon EC2 instance from your storage environment. For +// next steps, you can delete the VM or instance from your storage environment or +// reuse it to activate a new agent (https://docs.aws.amazon.com/datasync/latest/userguide/activate-agent.html) +// . func (c *Client) DeleteAgent(ctx context.Context, params *DeleteAgentInput, optFns ...func(*Options)) (*DeleteAgentOutput, error) { if params == nil { params = &DeleteAgentInput{} diff --git a/service/datasync/api_op_DescribeAgent.go b/service/datasync/api_op_DescribeAgent.go index 193dc88e3d1..464dbf6bd33 100644 --- a/service/datasync/api_op_DescribeAgent.go +++ b/service/datasync/api_op_DescribeAgent.go @@ -17,8 +17,8 @@ import ( "time" ) -// Returns metadata about an DataSync agent, such as its name, endpoint type, and -// status. +// Returns information about an DataSync agent, such as its name, service endpoint +// type, and status. func (c *Client) DescribeAgent(ctx context.Context, params *DescribeAgentInput, optFns ...func(*Options)) (*DescribeAgentOutput, error) { if params == nil { params = &DescribeAgentInput{} @@ -37,7 +37,8 @@ func (c *Client) DescribeAgent(ctx context.Context, params *DescribeAgentInput, // DescribeAgent type DescribeAgentInput struct { - // Specifies the Amazon Resource Name (ARN) of the DataSync agent to describe. + // Specifies the Amazon Resource Name (ARN) of the DataSync agent that you want + // information about. // // This member is required. AgentArn *string @@ -51,27 +52,33 @@ type DescribeAgentOutput struct { // The ARN of the agent. AgentArn *string - // The time that the agent was activated (that is, created in your account). + // The time that the agent was activated (https://docs.aws.amazon.com/datasync/latest/userguide/activate-agent.html) + // . CreationTime *time.Time - // The type of endpoint that your agent is connected to. If the endpoint is a VPC - // endpoint, the agent is not accessible over the public internet. + // The type of service endpoint (https://docs.aws.amazon.com/datasync/latest/userguide/choose-service-endpoint.html) + // that your agent is connected to. EndpointType types.EndpointType - // The time that the agent last connected to DataSync. + // The last time that the agent was communicating with the DataSync service. LastConnectionTime *time.Time // The name of the agent. Name *string - // The subnet and the security group that DataSync used to access a VPC endpoint. + // The platform-related details about the agent, such as the version number. + Platform *types.Platform + + // The network configuration that the agent uses when connecting to a VPC service + // endpoint (https://docs.aws.amazon.com/datasync/latest/userguide/choose-service-endpoint.html#choose-service-endpoint-vpc) + // . PrivateLinkConfig *types.PrivateLinkConfig - // The status of the agent. If the status is ONLINE, then the agent is configured - // properly and is available to use. The Running status is the normal running - // status for an agent. If the status is OFFLINE, the agent's VM is turned off or - // the agent is in an unhealthy state. When the issue that caused the unhealthy - // state is resolved, the agent returns to ONLINE status. + // The status of the agent. + // - If the status is ONLINE , the agent is configured properly and ready to use. + // - If the status is OFFLINE , the agent has been out of contact with DataSync + // for five minutes or longer. This can happen for a few reasons. For more + // information, see What do I do if my agent is offline? (https://docs.aws.amazon.com/datasync/latest/userguide/troubleshooting-datasync-agents.html#troubleshoot-agent-offline) Status types.AgentStatus // Metadata pertaining to the operation's result. diff --git a/service/datasync/api_op_DescribeTask.go b/service/datasync/api_op_DescribeTask.go index 7594f548523..28a7751f395 100644 --- a/service/datasync/api_op_DescribeTask.go +++ b/service/datasync/api_op_DescribeTask.go @@ -115,7 +115,7 @@ type DescribeTaskOutput struct { TaskArn *string // The configuration of your task report. For more information, see Creating a - // task report (https://docs.aws.amazon.com/https:/docs.aws.amazon.com/datasync/latest/userguide/creating-task-reports.html) + // task report (https://docs.aws.amazon.com/datasync/latest/userguide/task-reports.html) // . TaskReportConfig *types.TaskReportConfig diff --git a/service/datasync/api_op_DescribeTaskExecution.go b/service/datasync/api_op_DescribeTaskExecution.go index f16421c5659..653acf4e9ca 100644 --- a/service/datasync/api_op_DescribeTaskExecution.go +++ b/service/datasync/api_op_DescribeTaskExecution.go @@ -104,7 +104,10 @@ type DescribeTaskExecutionOutput struct { FilesTransferred int64 // The number of files, objects, and directories that DataSync verified during - // your transfer. + // your transfer. When you configure your task to verify only the data that's + // transferred (https://docs.aws.amazon.com/datasync/latest/userguide/configure-data-verification-options.html) + // , DataSync doesn't verify directories in some situations or files that fail to + // transfer. FilesVerified int64 // A list of filter rules that include specific data during your transfer. For @@ -120,7 +123,7 @@ type DescribeTaskExecutionOutput struct { // starting your task. Options *types.Options - // Indicates whether DataSync generated a complete task report (https://docs.aws.amazon.com/datasync/latest/userguide/creating-task-reports.html) + // Indicates whether DataSync generated a complete task report (https://docs.aws.amazon.com/datasync/latest/userguide/task-reports.html) // for your transfer. ReportResult *types.ReportResult diff --git a/service/datasync/api_op_UpdateAgent.go b/service/datasync/api_op_UpdateAgent.go index 38000688656..80a7e7fcdd8 100644 --- a/service/datasync/api_op_UpdateAgent.go +++ b/service/datasync/api_op_UpdateAgent.go @@ -15,7 +15,7 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Updates the name of an agent. +// Updates the name of an DataSync agent. func (c *Client) UpdateAgent(ctx context.Context, params *UpdateAgentInput, optFns ...func(*Options)) (*UpdateAgentOutput, error) { if params == nil { params = &UpdateAgentInput{} diff --git a/service/datasync/api_op_UpdateLocationSmb.go b/service/datasync/api_op_UpdateLocationSmb.go index 82b4fdc62b0..e55919e107f 100644 --- a/service/datasync/api_op_UpdateLocationSmb.go +++ b/service/datasync/api_op_UpdateLocationSmb.go @@ -16,10 +16,8 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Updates some of the parameters of a previously created location for Server -// Message Block (SMB) file system access. For information about creating an SMB -// location, see Creating a location for SMB (https://docs.aws.amazon.com/datasync/latest/userguide/create-smb-location.html) -// . +// Updates some of the parameters of a Server Message Block (SMB) file server +// location that you can use for DataSync transfers. func (c *Client) UpdateLocationSmb(ctx context.Context, params *UpdateLocationSmbInput, optFns ...func(*Options)) (*UpdateLocationSmbOutput, error) { if params == nil { params = &UpdateLocationSmbInput{} @@ -37,45 +35,46 @@ func (c *Client) UpdateLocationSmb(ctx context.Context, params *UpdateLocationSm type UpdateLocationSmbInput struct { - // The Amazon Resource Name (ARN) of the SMB location to update. + // Specifies the ARN of the SMB location that you want to update. // // This member is required. LocationArn *string - // The Amazon Resource Names (ARNs) of agents to use for a Simple Message Block - // (SMB) location. + // Specifies the DataSync agent (or agents) which you want to connect to your SMB + // file server. You specify an agent by using its Amazon Resource Name (ARN). AgentArns []string - // The name of the Windows domain that the SMB server belongs to. + // Specifies the Windows domain name that your SMB file server belongs to. If you + // have multiple domains in your environment, configuring this parameter makes sure + // that DataSync connects to the right file server. For more information, see + // required permissions (https://docs.aws.amazon.com/datasync/latest/userguide/create-smb-location.html#configuring-smb-permissions) + // for SMB locations. Domain *string // Specifies the version of the Server Message Block (SMB) protocol that DataSync // uses to access an SMB file server. MountOptions *types.SmbMountOptions - // The password of the user who can mount the share has the permissions to access - // files and folders in the SMB share. + // Specifies the password of the user who can mount your SMB file server and has + // permission to access the files and folders involved in your transfer. For more + // information, see required permissions (https://docs.aws.amazon.com/datasync/latest/userguide/create-smb-location.html#configuring-smb-permissions) + // for SMB locations. Password *string - // The subdirectory in the SMB file system that is used to read data from the SMB - // source location or write data to the SMB destination. The SMB path should be a - // path that's exported by the SMB server, or a subdirectory of that path. The path - // should be such that it can be mounted by other SMB clients in your network. - // Subdirectory must be specified with forward slashes. For example, - // /path/to/folder . To transfer all the data in the folder that you specified, - // DataSync must have permissions to mount the SMB share and to access all the data - // in that share. To ensure this, do either of the following: - // - Ensure that the user/password specified belongs to the user who can mount - // the share and who has the appropriate permissions for all of the files and - // directories that you want DataSync to access. - // - Use credentials of a member of the Backup Operators group to mount the - // share. - // Doing either of these options enables the agent to access the data. For the - // agent to access directories, you must also enable all execute access. + // Specifies the name of the share exported by your SMB file server where DataSync + // will read or write data. You can include a subdirectory in the share path (for + // example, /path/to/subdirectory ). Make sure that other SMB clients in your + // network can also mount this path. To copy all data in the specified + // subdirectory, DataSync must be able to mount the SMB share and access all of its + // data. For more information, see required permissions (https://docs.aws.amazon.com/datasync/latest/userguide/create-smb-location.html#configuring-smb-permissions) + // for SMB locations. Subdirectory *string - // The user who can mount the share has the permissions to access files and - // folders in the SMB share. + // Specifies the user name that can mount your SMB file server and has permission + // to access the files and folders involved in your transfer. For information about + // choosing a user with the right level of access for your transfer, see required + // permissions (https://docs.aws.amazon.com/datasync/latest/userguide/create-smb-location.html#configuring-smb-permissions) + // for SMB locations. User *string noSmithyDocumentSerde diff --git a/service/datasync/deserializers.go b/service/datasync/deserializers.go index 258bab2787c..51c1df33951 100644 --- a/service/datasync/deserializers.go +++ b/service/datasync/deserializers.go @@ -7041,6 +7041,11 @@ func awsAwsjson11_deserializeDocumentAgentListEntry(v **types.AgentListEntry, va sv.Name = ptr.String(jtv) } + case "Platform": + if err := awsAwsjson11_deserializeDocumentPlatform(&sv.Platform, value); err != nil { + return err + } + case "Status": if value != nil { jtv, ok := value.(string) @@ -9648,6 +9653,46 @@ func awsAwsjson11_deserializeDocumentP95Metrics(v **types.P95Metrics, value inte return nil } +func awsAwsjson11_deserializeDocumentPlatform(v **types.Platform, 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.Platform + if *v == nil { + sv = &types.Platform{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "Version": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AgentVersion to be of type string, got %T instead", value) + } + sv.Version = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeDocumentPLSecurityGroupArnList(v *[]string, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -11907,6 +11952,11 @@ func awsAwsjson11_deserializeOpDocumentDescribeAgentOutput(v **DescribeAgentOutp sv.Name = ptr.String(jtv) } + case "Platform": + if err := awsAwsjson11_deserializeDocumentPlatform(&sv.Platform, value); err != nil { + return err + } + case "PrivateLinkConfig": if err := awsAwsjson11_deserializeDocumentPrivateLinkConfig(&sv.PrivateLinkConfig, value); err != nil { return err diff --git a/service/datasync/endpoints.go b/service/datasync/endpoints.go index 4543c772517..bffc1156dfb 100644 --- a/service/datasync/endpoints.go +++ b/service/datasync/endpoints.go @@ -410,7 +410,7 @@ func (r *resolver) ResolveEndpoint( } } if _UseFIPS == true { - if true == _PartitionResult.SupportsFIPS { + if _PartitionResult.SupportsFIPS == true { uriString := func() string { var out strings.Builder out.WriteString("https://datasync-fips.") diff --git a/service/datasync/types/types.go b/service/datasync/types/types.go index 5d36d9f8f48..1aedb1e1ac9 100644 --- a/service/datasync/types/types.go +++ b/service/datasync/types/types.go @@ -18,8 +18,14 @@ type AgentListEntry struct { // The name of an agent. Name *string - // The status of an agent. For more information, see DataSync agent statuses (https://docs.aws.amazon.com/datasync/latest/userguide/understand-agent-statuses.html) - // . + // The platform-related details about the agent, such as the version number. + Platform *Platform + + // The status of an agent. + // - If the status is ONLINE , the agent is configured properly and ready to use. + // - If the status is OFFLINE , the agent has been out of contact with DataSync + // for five minutes or longer. This can happen for a few reasons. For more + // information, see What do I do if my agent is offline? (https://docs.aws.amazon.com/datasync/latest/userguide/troubleshooting-datasync-agents.html#troubleshoot-agent-offline) Status AgentStatus noSmithyDocumentSerde @@ -744,9 +750,24 @@ type P95Metrics struct { noSmithyDocumentSerde } +// The platform-related details about the DataSync agent, such as the version +// number. +type Platform struct { + + // The version of the DataSync agent. Beginning December 7, 2023, we will + // discontinue version 1 DataSync agents. Check the DataSync console to see if you + // have affected agents. If you do, replace (https://docs.aws.amazon.com/datasync/latest/userguide/replacing-agent.html) + // those agents before then to avoid data transfer or storage discovery + // disruptions. If you need more help, contact Amazon Web Services Support (https://aws.amazon.com/contact-us/) + // . + Version *string + + noSmithyDocumentSerde +} + // Specifies how your DataSync agent connects to Amazon Web Services using a -// virtual private cloud (VPC) service endpoint. An agent that uses a VPC endpoint -// isn't accessible over the public internet. +// virtual private cloud (VPC) service endpoint (https://docs.aws.amazon.com/datasync/latest/userguide/choose-service-endpoint.html#choose-service-endpoint-vpc) +// . An agent that uses a VPC endpoint isn't accessible over the public internet. type PrivateLinkConfig struct { // Specifies the VPC endpoint provided by Amazon Web Services PrivateLink (https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-service.html) @@ -807,7 +828,7 @@ type Recommendation struct { noSmithyDocumentSerde } -// Specifies where DataSync uploads your task report (https://docs.aws.amazon.com/datasync/latest/userguide/creating-task-reports.html) +// Specifies where DataSync uploads your task report (https://docs.aws.amazon.com/datasync/latest/userguide/task-reports.html) // . type ReportDestination struct { @@ -817,13 +838,13 @@ type ReportDestination struct { noSmithyDocumentSerde } -// Specifies the Amazon S3 bucket where DataSync uploads your task report (https://docs.aws.amazon.com/datasync/latest/userguide/creating-task-reports.html) +// Specifies the Amazon S3 bucket where DataSync uploads your task report (https://docs.aws.amazon.com/datasync/latest/userguide/task-reports.html) // . type ReportDestinationS3 struct { // Specifies the Amazon Resource Name (ARN) of the IAM policy that allows DataSync // to upload a task report to your S3 bucket. For more information, see Allowing - // DataSync to upload a task report to an Amazon S3 bucket (https://docs.aws.amazon.com/https:/docs.aws.amazon.com/datasync/latest/userguide/creating-task-reports.html) + // DataSync to upload a task report to an Amazon S3 bucket (https://docs.aws.amazon.com/https:/docs.aws.amazon.com/datasync/latest/userguide/task-reports.html) // . // // This member is required. @@ -841,7 +862,7 @@ type ReportDestinationS3 struct { } // Specifies the level of detail for a particular aspect of your DataSync task -// report (https://docs.aws.amazon.com/datasync/latest/userguide/creating-task-reports.html) +// report (https://docs.aws.amazon.com/datasync/latest/userguide/task-reports.html) // . type ReportOverride struct { @@ -857,7 +878,7 @@ type ReportOverride struct { noSmithyDocumentSerde } -// The level of detail included in each aspect of your DataSync task report (https://docs.aws.amazon.com/datasync/latest/userguide/creating-task-reports.html) +// The level of detail included in each aspect of your DataSync task report (https://docs.aws.amazon.com/datasync/latest/userguide/task-reports.html) // . type ReportOverrides struct { @@ -882,7 +903,7 @@ type ReportOverrides struct { noSmithyDocumentSerde } -// Indicates whether DataSync created a complete task report (https://docs.aws.amazon.com/datasync/latest/userguide/creating-task-reports.html) +// Indicates whether DataSync created a complete task report (https://docs.aws.amazon.com/datasync/latest/userguide/task-reports.html) // for your transfer. type ReportResult struct { @@ -1110,12 +1131,12 @@ type TaskListEntry struct { // Specifies how you want to configure a task report, which provides detailed // information about for your DataSync transfer. For more information, see Task -// reports (https://docs.aws.amazon.com/datasync/latest/userguide/creating-task-reports.html) +// reports (https://docs.aws.amazon.com/datasync/latest/userguide/task-reports.html) // . type TaskReportConfig struct { // Specifies the Amazon S3 bucket where DataSync uploads your task report. For - // more information, see Task reports (https://docs.aws.amazon.com/datasync/latest/userguide/creating-task-reports.html#task-report-access) + // more information, see Task reports (https://docs.aws.amazon.com/datasync/latest/userguide/task-reports.html#task-report-access) // . Destination *ReportDestination diff --git a/service/finspace/api_op_UpdateKxClusterCodeConfiguration.go b/service/finspace/api_op_UpdateKxClusterCodeConfiguration.go new file mode 100644 index 00000000000..a296a32bfab --- /dev/null +++ b/service/finspace/api_op_UpdateKxClusterCodeConfiguration.go @@ -0,0 +1,324 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package finspace + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + internalauth "github.com/aws/aws-sdk-go-v2/internal/auth" + "github.com/aws/aws-sdk-go-v2/service/finspace/types" + smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Allows you to update code configuration on a running cluster. By using this API +// you can update the code, the initialization script path, and the command line +// arguments for a specific cluster. The configuration that you want to update will +// override any existing configurations on the cluster. +func (c *Client) UpdateKxClusterCodeConfiguration(ctx context.Context, params *UpdateKxClusterCodeConfigurationInput, optFns ...func(*Options)) (*UpdateKxClusterCodeConfigurationOutput, error) { + if params == nil { + params = &UpdateKxClusterCodeConfigurationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "UpdateKxClusterCodeConfiguration", params, optFns, c.addOperationUpdateKxClusterCodeConfigurationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*UpdateKxClusterCodeConfigurationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type UpdateKxClusterCodeConfigurationInput struct { + + // The name of the cluster. + // + // This member is required. + ClusterName *string + + // The structure of the customer code available within the running cluster. + // + // This member is required. + Code *types.CodeConfiguration + + // A unique identifier of the kdb environment. + // + // This member is required. + EnvironmentId *string + + // A token that ensures idempotency. This token expires in 10 minutes. + ClientToken *string + + // Specifies the key-value pairs to make them available inside the cluster. + CommandLineArguments []types.KxCommandLineArgument + + // The configuration that allows you to choose how you want to update the code on + // a cluster. + DeploymentConfiguration *types.KxClusterCodeDeploymentConfiguration + + // Specifies a Q program that will be run at launch of a cluster. It is a relative + // path within .zip file that contains the custom code, which will be loaded on the + // cluster. It must include the file name itself. For example, somedir/init.q . + InitializationScript *string + + noSmithyDocumentSerde +} + +type UpdateKxClusterCodeConfigurationOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationUpdateKxClusterCodeConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateKxClusterCodeConfiguration{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateKxClusterCodeConfiguration{}, middleware.After) + if err != nil { + return err + } + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = addRestJsonContentTypeCustomization(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addUpdateKxClusterCodeConfigurationResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addIdempotencyToken_opUpdateKxClusterCodeConfigurationMiddleware(stack, options); err != nil { + return err + } + if err = addOpUpdateKxClusterCodeConfigurationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateKxClusterCodeConfiguration(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + return nil +} + +type idempotencyToken_initializeOpUpdateKxClusterCodeConfiguration struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateKxClusterCodeConfiguration) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateKxClusterCodeConfiguration) 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.(*UpdateKxClusterCodeConfigurationInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateKxClusterCodeConfigurationInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateKxClusterCodeConfigurationMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateKxClusterCodeConfiguration{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + +func newServiceMetadataMiddleware_opUpdateKxClusterCodeConfiguration(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "finspace", + OperationName: "UpdateKxClusterCodeConfiguration", + } +} + +type opUpdateKxClusterCodeConfigurationResolveEndpointMiddleware struct { + EndpointResolver EndpointResolverV2 + BuiltInResolver builtInParameterResolver +} + +func (*opUpdateKxClusterCodeConfigurationResolveEndpointMiddleware) ID() string { + return "ResolveEndpointV2" +} + +func (m *opUpdateKxClusterCodeConfigurationResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if awsmiddleware.GetRequiresLegacyEndpoints(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + if m.EndpointResolver == nil { + return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil") + } + + params := EndpointParameters{} + + m.BuiltInResolver.ResolveBuiltIns(¶ms) + + var resolvedEndpoint smithyendpoints.Endpoint + resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params) + if err != nil { + return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err) + } + + req.URL = &resolvedEndpoint.URI + + for k := range resolvedEndpoint.Headers { + req.Header.Set( + k, + resolvedEndpoint.Headers.Get(k), + ) + } + + authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties) + if err != nil { + var nfe *internalauth.NoAuthenticationSchemesFoundError + if errors.As(err, &nfe) { + // if no auth scheme is found, default to sigv4 + signingName := "finspace" + signingRegion := m.BuiltInResolver.(*builtInResolver).Region + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + + } + var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError + if errors.As(err, &ue) { + return out, metadata, fmt.Errorf( + "This operation requests signer version(s) %v but the client only supports %v", + ue.UnsupportedSchemes, + internalauth.SupportedSchemes, + ) + } + } + + for _, authScheme := range authSchemes { + switch authScheme.(type) { + case *internalauth.AuthenticationSchemeV4: + v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4) + var signingName, signingRegion string + if v4Scheme.SigningName == nil { + signingName = "finspace" + } else { + signingName = *v4Scheme.SigningName + } + if v4Scheme.SigningRegion == nil { + signingRegion = m.BuiltInResolver.(*builtInResolver).Region + } else { + signingRegion = *v4Scheme.SigningRegion + } + if v4Scheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + break + case *internalauth.AuthenticationSchemeV4A: + v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A) + if v4aScheme.SigningName == nil { + v4aScheme.SigningName = aws.String("finspace") + } + if v4aScheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName) + ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0]) + break + case *internalauth.AuthenticationSchemeNone: + break + } + } + + return next.HandleSerialize(ctx, in) +} + +func addUpdateKxClusterCodeConfigurationResolveEndpointMiddleware(stack *middleware.Stack, options Options) error { + return stack.Serialize.Insert(&opUpdateKxClusterCodeConfigurationResolveEndpointMiddleware{ + EndpointResolver: options.EndpointResolverV2, + BuiltInResolver: &builtInResolver{ + Region: options.Region, + UseDualStack: options.EndpointOptions.UseDualStackEndpoint, + UseFIPS: options.EndpointOptions.UseFIPSEndpoint, + Endpoint: options.BaseEndpoint, + }, + }, "ResolveEndpoint", middleware.After) +} diff --git a/service/finspace/deserializers.go b/service/finspace/deserializers.go index 07d4ca7800c..cfe80dbbc65 100644 --- a/service/finspace/deserializers.go +++ b/service/finspace/deserializers.go @@ -5229,6 +5229,107 @@ func awsRestjson1_deserializeOpDocumentUpdateEnvironmentOutput(v **UpdateEnviron return nil } +type awsRestjson1_deserializeOpUpdateKxClusterCodeConfiguration struct { +} + +func (*awsRestjson1_deserializeOpUpdateKxClusterCodeConfiguration) ID() string { + return "OperationDeserializer" +} + +func (m *awsRestjson1_deserializeOpUpdateKxClusterCodeConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsRestjson1_deserializeOpErrorUpdateKxClusterCodeConfiguration(response, &metadata) + } + output := &UpdateKxClusterCodeConfigurationOutput{} + out.Result = output + + return out, metadata, err +} + +func awsRestjson1_deserializeOpErrorUpdateKxClusterCodeConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsRestjson1_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("LimitExceededException", errorCode): + return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsRestjson1_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsRestjson1_deserializeOpUpdateKxClusterDatabases struct { } diff --git a/service/finspace/generated.json b/service/finspace/generated.json index efea387a8af..90db072e03c 100644 --- a/service/finspace/generated.json +++ b/service/finspace/generated.json @@ -38,6 +38,7 @@ "api_op_TagResource.go", "api_op_UntagResource.go", "api_op_UpdateEnvironment.go", + "api_op_UpdateKxClusterCodeConfiguration.go", "api_op_UpdateKxClusterDatabases.go", "api_op_UpdateKxDatabase.go", "api_op_UpdateKxEnvironment.go", diff --git a/service/finspace/serializers.go b/service/finspace/serializers.go index 6616ea03a85..85e02b94b20 100644 --- a/service/finspace/serializers.go +++ b/service/finspace/serializers.go @@ -2449,6 +2449,129 @@ func awsRestjson1_serializeOpDocumentUpdateEnvironmentInput(v *UpdateEnvironment return nil } +type awsRestjson1_serializeOpUpdateKxClusterCodeConfiguration struct { +} + +func (*awsRestjson1_serializeOpUpdateKxClusterCodeConfiguration) ID() string { + return "OperationSerializer" +} + +func (m *awsRestjson1_serializeOpUpdateKxClusterCodeConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*UpdateKxClusterCodeConfigurationInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + opPath, opQuery := httpbinding.SplitURI("/kx/environments/{environmentId}/clusters/{clusterName}/configuration/code") + request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) + request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) + request.Method = "PUT" + var restEncoder *httpbinding.Encoder + if request.URL.RawPath == "" { + restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + } else { + request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) + restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) + } + + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if err := awsRestjson1_serializeOpHttpBindingsUpdateKxClusterCodeConfigurationInput(input, restEncoder); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + restEncoder.SetHeader("Content-Type").String("application/json") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsRestjson1_serializeOpDocumentUpdateKxClusterCodeConfigurationInput(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 = restEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} +func awsRestjson1_serializeOpHttpBindingsUpdateKxClusterCodeConfigurationInput(v *UpdateKxClusterCodeConfigurationInput, encoder *httpbinding.Encoder) error { + if v == nil { + return fmt.Errorf("unsupported serialization of nil %T", v) + } + + if v.ClusterName == nil || len(*v.ClusterName) == 0 { + return &smithy.SerializationError{Err: fmt.Errorf("input member clusterName must not be empty")} + } + if v.ClusterName != nil { + if err := encoder.SetURI("clusterName").String(*v.ClusterName); err != nil { + return err + } + } + + if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 { + return &smithy.SerializationError{Err: fmt.Errorf("input member environmentId must not be empty")} + } + if v.EnvironmentId != nil { + if err := encoder.SetURI("environmentId").String(*v.EnvironmentId); err != nil { + return err + } + } + + return nil +} + +func awsRestjson1_serializeOpDocumentUpdateKxClusterCodeConfigurationInput(v *UpdateKxClusterCodeConfigurationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ClientToken != nil { + ok := object.Key("clientToken") + ok.String(*v.ClientToken) + } + + if v.Code != nil { + ok := object.Key("code") + if err := awsRestjson1_serializeDocumentCodeConfiguration(v.Code, ok); err != nil { + return err + } + } + + if v.CommandLineArguments != nil { + ok := object.Key("commandLineArguments") + if err := awsRestjson1_serializeDocumentKxCommandLineArguments(v.CommandLineArguments, ok); err != nil { + return err + } + } + + if v.DeploymentConfiguration != nil { + ok := object.Key("deploymentConfiguration") + if err := awsRestjson1_serializeDocumentKxClusterCodeDeploymentConfiguration(v.DeploymentConfiguration, ok); err != nil { + return err + } + } + + if v.InitializationScript != nil { + ok := object.Key("initializationScript") + ok.String(*v.InitializationScript) + } + + return nil +} + type awsRestjson1_serializeOpUpdateKxClusterDatabases struct { } @@ -3263,6 +3386,18 @@ func awsRestjson1_serializeDocumentKxCacheStorageConfigurations(v []types.KxCach return nil } +func awsRestjson1_serializeDocumentKxClusterCodeDeploymentConfiguration(v *types.KxClusterCodeDeploymentConfiguration, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if len(v.DeploymentStrategy) > 0 { + ok := object.Key("deploymentStrategy") + ok.String(string(v.DeploymentStrategy)) + } + + return nil +} + func awsRestjson1_serializeDocumentKxCommandLineArgument(v *types.KxCommandLineArgument, value smithyjson.Value) error { object := value.Object() defer object.Close() diff --git a/service/finspace/types/enums.go b/service/finspace/types/enums.go index d73b71f2e01..2317f4ff638 100644 --- a/service/finspace/types/enums.go +++ b/service/finspace/types/enums.go @@ -204,6 +204,25 @@ func (KxAzMode) Values() []KxAzMode { } } +type KxClusterCodeDeploymentStrategy string + +// Enum values for KxClusterCodeDeploymentStrategy +const ( + KxClusterCodeDeploymentStrategyRolling KxClusterCodeDeploymentStrategy = "ROLLING" + KxClusterCodeDeploymentStrategyForce KxClusterCodeDeploymentStrategy = "FORCE" +) + +// Values returns all known values for KxClusterCodeDeploymentStrategy. 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 (KxClusterCodeDeploymentStrategy) Values() []KxClusterCodeDeploymentStrategy { + return []KxClusterCodeDeploymentStrategy{ + "ROLLING", + "FORCE", + } +} + type KxClusterStatus string // Enum values for KxClusterStatus diff --git a/service/finspace/types/types.go b/service/finspace/types/types.go index 7eb29970cac..f9d99910bfc 100644 --- a/service/finspace/types/types.go +++ b/service/finspace/types/types.go @@ -237,8 +237,13 @@ type KxCacheStorageConfiguration struct { // This member is required. Size *int32 - // The type of cache storage . The valid values are: + // The type of cache storage. The valid values are: // - CACHE_1000 – This type provides at least 1000 MB/s disk access throughput. + // - CACHE_250 – This type provides at least 250 MB/s disk access throughput. + // - CACHE_12 – This type provides at least 12 MB/s disk access throughput. + // For cache type CACHE_1000 and CACHE_250 you can select cache size as 1200 GB or + // increments of 2400 GB. For cache type CACHE_12 you can select the cache size in + // increments of 6000 GB. // // This member is required. Type *string @@ -351,6 +356,23 @@ type KxCluster struct { noSmithyDocumentSerde } +// The configuration that allows you to choose how you want to update code on a +// cluster. Depending on the option you choose, you can reduce the time it takes to +// update the cluster. +type KxClusterCodeDeploymentConfiguration struct { + + // The type of deployment that you want on a cluster. + // - ROLLING – This options updates the cluster by stopping the exiting q + // process and starting a new q process with updated configuration. + // - FORCE – This option updates the cluster by immediately stopping all the + // running processes before starting up new ones with the updated configuration. + // + // This member is required. + DeploymentStrategy KxClusterCodeDeploymentStrategy + + noSmithyDocumentSerde +} + // Defines the key-value pairs to make them available inside the cluster. type KxCommandLineArgument struct { @@ -423,15 +445,17 @@ type KxDatabaseListEntry struct { // The configuration that allows you to choose how you want to update the // databases on a cluster. Depending on the option you choose, you can reduce the -// time it takes to update the database changesets on to a cluster. +// time it takes to update the cluster. type KxDeploymentConfiguration struct { // The type of deployment that you want on a cluster. - // - ROLLING – This options loads the updated database by stopping the exiting q + // - ROLLING – This options updates the cluster by stopping the exiting q // process and starting a new q process with updated configuration. - // - NO_RESTART – This option loads the updated database on the running q - // process without stopping it. This option is quicker as it reduces the turn - // around time to update a kdb database changeset configuration on a cluster. + // - NO_RESTART – This option updates the cluster without stopping the running q + // process. It is only available for HDB type cluster. This option is quicker as + // it reduces the turn around time to update configuration on a cluster. With this + // deployment mode, you cannot update the initializationScript and + // commandLineArguments parameters. // // This member is required. DeploymentStrategy KxDeploymentStrategy diff --git a/service/finspace/validators.go b/service/finspace/validators.go index ac58f66fdea..e51c88ddcf8 100644 --- a/service/finspace/validators.go +++ b/service/finspace/validators.go @@ -550,6 +550,26 @@ func (m *validateOpUpdateEnvironment) HandleInitialize(ctx context.Context, in m return next.HandleInitialize(ctx, in) } +type validateOpUpdateKxClusterCodeConfiguration struct { +} + +func (*validateOpUpdateKxClusterCodeConfiguration) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpUpdateKxClusterCodeConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*UpdateKxClusterCodeConfigurationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpUpdateKxClusterCodeConfigurationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpUpdateKxClusterDatabases struct { } @@ -758,6 +778,10 @@ func addOpUpdateEnvironmentValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpUpdateEnvironment{}, middleware.After) } +func addOpUpdateKxClusterCodeConfigurationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpUpdateKxClusterCodeConfiguration{}, middleware.After) +} + func addOpUpdateKxClusterDatabasesValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpUpdateKxClusterDatabases{}, middleware.After) } @@ -895,6 +919,21 @@ func validateKxCacheStorageConfigurations(v []types.KxCacheStorageConfiguration) } } +func validateKxClusterCodeDeploymentConfiguration(v *types.KxClusterCodeDeploymentConfiguration) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "KxClusterCodeDeploymentConfiguration"} + if len(v.DeploymentStrategy) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("DeploymentStrategy")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateKxDatabaseCacheConfiguration(v *types.KxDatabaseCacheConfiguration) error { if v == nil { return nil @@ -1620,6 +1659,32 @@ func validateOpUpdateEnvironmentInput(v *UpdateEnvironmentInput) error { } } +func validateOpUpdateKxClusterCodeConfigurationInput(v *UpdateKxClusterCodeConfigurationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "UpdateKxClusterCodeConfigurationInput"} + if v.EnvironmentId == nil { + invalidParams.Add(smithy.NewErrParamRequired("EnvironmentId")) + } + if v.ClusterName == nil { + invalidParams.Add(smithy.NewErrParamRequired("ClusterName")) + } + if v.Code == nil { + invalidParams.Add(smithy.NewErrParamRequired("Code")) + } + if v.DeploymentConfiguration != nil { + if err := validateKxClusterCodeDeploymentConfiguration(v.DeploymentConfiguration); err != nil { + invalidParams.AddNested("DeploymentConfiguration", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpUpdateKxClusterDatabasesInput(v *UpdateKxClusterDatabasesInput) error { if v == nil { return nil diff --git a/service/mediapackagev2/deserializers.go b/service/mediapackagev2/deserializers.go index 522d9ff3c9f..75af7c8d5e2 100644 --- a/service/mediapackagev2/deserializers.go +++ b/service/mediapackagev2/deserializers.go @@ -2614,6 +2614,9 @@ func awsRestjson1_deserializeOpErrorListChannels(response *smithyhttp.Response, case strings.EqualFold("InternalServerException", errorCode): return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) @@ -4903,6 +4906,91 @@ func awsRestjson1_deserializeDocumentEncryptionMethod(v **types.EncryptionMethod return nil } +func awsRestjson1_deserializeDocumentFilterConfiguration(v **types.FilterConfiguration, 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.FilterConfiguration + if *v == nil { + sv = &types.FilterConfiguration{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "End": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.End = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) + + } + } + + case "ManifestFilter": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ManifestFilter = ptr.String(jtv) + } + + case "Start": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.Start = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) + + } + } + + case "TimeDelaySeconds": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.TimeDelaySeconds = ptr.Int32(int32(i64)) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsRestjson1_deserializeDocumentGetHlsManifestConfiguration(v **types.GetHlsManifestConfiguration, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -4934,6 +5022,11 @@ func awsRestjson1_deserializeDocumentGetHlsManifestConfiguration(v **types.GetHl sv.ChildManifestName = ptr.String(jtv) } + case "FilterConfiguration": + if err := awsRestjson1_deserializeDocumentFilterConfiguration(&sv.FilterConfiguration, value); err != nil { + return err + } + case "ManifestName": if value != nil { jtv, ok := value.(string) @@ -5057,6 +5150,11 @@ func awsRestjson1_deserializeDocumentGetLowLatencyHlsManifestConfiguration(v **t sv.ChildManifestName = ptr.String(jtv) } + case "FilterConfiguration": + if err := awsRestjson1_deserializeDocumentFilterConfiguration(&sv.FilterConfiguration, value); err != nil { + return err + } + case "ManifestName": if value != nil { jtv, ok := value.(string) diff --git a/service/mediapackagev2/serializers.go b/service/mediapackagev2/serializers.go index 2967d201cf1..81482ca376d 100644 --- a/service/mediapackagev2/serializers.go +++ b/service/mediapackagev2/serializers.go @@ -11,6 +11,7 @@ import ( "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" smithyhttp "github.com/aws/smithy-go/transport/http" ) @@ -2097,6 +2098,13 @@ func awsRestjson1_serializeDocumentCreateHlsManifestConfiguration(v *types.Creat ok.String(*v.ChildManifestName) } + if v.FilterConfiguration != nil { + ok := object.Key("FilterConfiguration") + if err := awsRestjson1_serializeDocumentFilterConfiguration(v.FilterConfiguration, ok); err != nil { + return err + } + } + if v.ManifestName != nil { ok := object.Key("ManifestName") ok.String(*v.ManifestName) @@ -2144,6 +2152,13 @@ func awsRestjson1_serializeDocumentCreateLowLatencyHlsManifestConfiguration(v *t ok.String(*v.ChildManifestName) } + if v.FilterConfiguration != nil { + ok := object.Key("FilterConfiguration") + if err := awsRestjson1_serializeDocumentFilterConfiguration(v.FilterConfiguration, ok); err != nil { + return err + } + } + if v.ManifestName != nil { ok := object.Key("ManifestName") ok.String(*v.ManifestName) @@ -2258,6 +2273,33 @@ func awsRestjson1_serializeDocumentEncryptionMethod(v *types.EncryptionMethod, v return nil } +func awsRestjson1_serializeDocumentFilterConfiguration(v *types.FilterConfiguration, 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.ManifestFilter != nil { + ok := object.Key("ManifestFilter") + ok.String(*v.ManifestFilter) + } + + if v.Start != nil { + ok := object.Key("Start") + ok.Double(smithytime.FormatEpochSeconds(*v.Start)) + } + + if v.TimeDelaySeconds != nil { + ok := object.Key("TimeDelaySeconds") + ok.Integer(*v.TimeDelaySeconds) + } + + return nil +} + func awsRestjson1_serializeDocumentScte(v *types.Scte, value smithyjson.Value) error { object := value.Object() defer object.Close() diff --git a/service/mediapackagev2/types/enums.go b/service/mediapackagev2/types/enums.go index 2cb1844a34a..64730f85c84 100644 --- a/service/mediapackagev2/types/enums.go +++ b/service/mediapackagev2/types/enums.go @@ -264,6 +264,9 @@ const ( ValidationExceptionTypeMemberMaxLength ValidationExceptionType = "MEMBER_MAX_LENGTH" ValidationExceptionTypeMemberInvalidEnumValue ValidationExceptionType = "MEMBER_INVALID_ENUM_VALUE" ValidationExceptionTypeMemberDoesNotMatchPattern ValidationExceptionType = "MEMBER_DOES_NOT_MATCH_PATTERN" + ValidationExceptionTypeInvalidManifestFilter ValidationExceptionType = "INVALID_MANIFEST_FILTER" + ValidationExceptionTypeInvalidTimeDelaySeconds ValidationExceptionType = "INVALID_TIME_DELAY_SECONDS" + ValidationExceptionTypeEndTimeEarlierThanStartTime ValidationExceptionType = "END_TIME_EARLIER_THAN_START_TIME" ) // Values returns all known values for ValidationExceptionType. Note that this can @@ -305,5 +308,8 @@ func (ValidationExceptionType) Values() []ValidationExceptionType { "MEMBER_MAX_LENGTH", "MEMBER_INVALID_ENUM_VALUE", "MEMBER_DOES_NOT_MATCH_PATTERN", + "INVALID_MANIFEST_FILTER", + "INVALID_TIME_DELAY_SECONDS", + "END_TIME_EARLIER_THAN_START_TIME", } } diff --git a/service/mediapackagev2/types/types.go b/service/mediapackagev2/types/types.go index 8cb97cd3978..60604b751a0 100644 --- a/service/mediapackagev2/types/types.go +++ b/service/mediapackagev2/types/types.go @@ -96,6 +96,11 @@ type CreateHlsManifestConfiguration struct { // manifestName you provided on the originEndpoint object. ChildManifestName *string + // Filter configuration includes settings for manifest filtering, start and end + // times, and time delay that apply to all of your egress requests for this + // manifest. + FilterConfiguration *FilterConfiguration + // The total duration (in seconds) of the manifest's content. ManifestWindowSeconds *int32 @@ -134,6 +139,11 @@ type CreateLowLatencyHlsManifestConfiguration struct { // manifestName you provided on the originEndpoint object. ChildManifestName *string + // Filter configuration includes settings for manifest filtering, start and end + // times, and time delay that apply to all of your egress requests for this + // manifest. + FilterConfiguration *FilterConfiguration + // The total duration (in seconds) of the manifest's content. ManifestWindowSeconds *int32 @@ -250,6 +260,35 @@ type EncryptionMethod struct { noSmithyDocumentSerde } +// Filter configuration includes settings for manifest filtering, start and end +// times, and time delay that apply to all of your egress requests for this +// manifest. +type FilterConfiguration struct { + + // Optionally specify the end time for all of your manifest egress requests. When + // you include end time, note that you cannot use end time query parameters for + // this manifest's endpoint URL. + End *time.Time + + // Optionally specify one or more manifest filters for all of your manifest egress + // requests. When you include a manifest filter, note that you cannot use an + // identical manifest filter query parameter for this manifest's endpoint URL. + ManifestFilter *string + + // Optionally specify the start time for all of your manifest egress requests. + // When you include start time, note that you cannot use start time query + // parameters for this manifest's endpoint URL. + Start *time.Time + + // Optionally specify the time delay for all of your manifest egress requests. + // Enter a value that is smaller than your endpoint's startover window. When you + // include time delay, note that you cannot use time delay query parameters for + // this manifest's endpoint URL. + TimeDelaySeconds *int32 + + noSmithyDocumentSerde +} + // Retrieve the HTTP live streaming (HLS) manifest configuration. type GetHlsManifestConfiguration struct { @@ -275,6 +314,11 @@ type GetHlsManifestConfiguration struct { // object. ChildManifestName *string + // Filter configuration includes settings for manifest filtering, start and end + // times, and time delay that apply to all of your egress requests for this + // manifest. + FilterConfiguration *FilterConfiguration + // The total duration (in seconds) of the manifest's content. ManifestWindowSeconds *int32 @@ -318,6 +362,11 @@ type GetLowLatencyHlsManifestConfiguration struct { // object. ChildManifestName *string + // Filter configuration includes settings for manifest filtering, start and end + // times, and time delay that apply to all of your egress requests for this + // manifest. + FilterConfiguration *FilterConfiguration + // The total duration (in seconds) of the manifest's content. ManifestWindowSeconds *int32 diff --git a/service/rds/api_op_CreateCustomDBEngineVersion.go b/service/rds/api_op_CreateCustomDBEngineVersion.go index 7a842a55111..724ea98fd47 100644 --- a/service/rds/api_op_CreateCustomDBEngineVersion.go +++ b/service/rds/api_op_CreateCustomDBEngineVersion.go @@ -215,6 +215,10 @@ type CreateCustomDBEngineVersionOutput struct { // version. SupportsGlobalDatabases *bool + // Indicates whether the DB engine version supports Aurora zero-ETL integrations + // with Amazon Redshift. + SupportsIntegrations *bool + // Indicates whether the DB engine version supports forwarding write operations // from reader DB instances to the writer DB instance in the DB cluster. By // default, write operations aren't allowed on reader DB instances. Valid for: diff --git a/service/rds/api_op_CreateIntegration.go b/service/rds/api_op_CreateIntegration.go new file mode 100644 index 00000000000..e22125f3b97 --- /dev/null +++ b/service/rds/api_op_CreateIntegration.go @@ -0,0 +1,326 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package rds + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + internalauth "github.com/aws/aws-sdk-go-v2/internal/auth" + "github.com/aws/aws-sdk-go-v2/service/rds/types" + smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" + "time" +) + +// Creates a zero-ETL integration with Amazon Redshift. For more information, see +// Working with Amazon Aurora zero-ETL integrations with Amazon Redshift (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/zero-etl.html) +// in the Amazon Aurora User Guide. +func (c *Client) CreateIntegration(ctx context.Context, params *CreateIntegrationInput, optFns ...func(*Options)) (*CreateIntegrationOutput, error) { + if params == nil { + params = &CreateIntegrationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateIntegration", params, optFns, c.addOperationCreateIntegrationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateIntegrationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateIntegrationInput struct { + + // The name of the integration. + // + // This member is required. + IntegrationName *string + + // The Amazon Resource Name (ARN) of the Aurora DB cluster to use as the source + // for replication. + // + // This member is required. + SourceArn *string + + // The ARN of the Redshift data warehouse to use as the target for replication. + // + // This member is required. + TargetArn *string + + // An optional set of non-secret key–value pairs that contains additional + // contextual information about the data. For more information, see Encryption + // context (https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) + // in the Amazon Web Services Key Management Service Developer Guide. You can only + // include this parameter if you specify the KMSKeyId parameter. + AdditionalEncryptionContext map[string]string + + // The Amazon Web Services Key Management System (Amazon Web Services KMS) key + // identifier for the key to use to encrypt the integration. If you don't specify + // an encryption key, Aurora uses a default Amazon Web Services owned key. + KMSKeyId *string + + // A list of tags. For more information, see Tagging Amazon RDS Resources (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) + // in the Amazon RDS User Guide. + Tags []types.Tag + + noSmithyDocumentSerde +} + +// An Aurora zero-ETL integration with Amazon Redshift. For more information, see +// Working with Amazon Aurora zero-ETL integrations with Amazon Redshift (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/zero-etl.html) +// in the Amazon Aurora User Guide. +type CreateIntegrationOutput struct { + + // The encryption context for the integration. For more information, see + // Encryption context (https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) + // in the Amazon Web Services Key Management Service Developer Guide. + AdditionalEncryptionContext map[string]string + + // The time when the integration was created, in Universal Coordinated Time (UTC). + CreateTime *time.Time + + // Any errors associated with the integration. + Errors []types.IntegrationError + + // The ARN of the integration. + IntegrationArn *string + + // The name of the integration. + IntegrationName *string + + // The Amazon Web Services Key Management System (Amazon Web Services KMS) key + // identifier for the key used to to encrypt the integration. + KMSKeyId *string + + // The Amazon Resource Name (ARN) of the Aurora DB cluster used as the source for + // replication. + SourceArn *string + + // The current status of the integration. + Status types.IntegrationStatus + + // A list of tags. For more information, see Tagging Amazon RDS Resources (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) + // in the Amazon RDS User Guide. + Tags []types.Tag + + // The ARN of the Redshift data warehouse used as the target for replication. + TargetArn *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationCreateIntegrationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsquery_serializeOpCreateIntegration{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsquery_deserializeOpCreateIntegration{}, middleware.After) + if err != nil { + return err + } + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack, 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 = addCreateIntegrationResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addOpCreateIntegrationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateIntegration(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opCreateIntegration(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "rds", + OperationName: "CreateIntegration", + } +} + +type opCreateIntegrationResolveEndpointMiddleware struct { + EndpointResolver EndpointResolverV2 + BuiltInResolver builtInParameterResolver +} + +func (*opCreateIntegrationResolveEndpointMiddleware) ID() string { + return "ResolveEndpointV2" +} + +func (m *opCreateIntegrationResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if awsmiddleware.GetRequiresLegacyEndpoints(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + if m.EndpointResolver == nil { + return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil") + } + + params := EndpointParameters{} + + m.BuiltInResolver.ResolveBuiltIns(¶ms) + + var resolvedEndpoint smithyendpoints.Endpoint + resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params) + if err != nil { + return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err) + } + + req.URL = &resolvedEndpoint.URI + + for k := range resolvedEndpoint.Headers { + req.Header.Set( + k, + resolvedEndpoint.Headers.Get(k), + ) + } + + authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties) + if err != nil { + var nfe *internalauth.NoAuthenticationSchemesFoundError + if errors.As(err, &nfe) { + // if no auth scheme is found, default to sigv4 + signingName := "rds" + signingRegion := m.BuiltInResolver.(*builtInResolver).Region + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + + } + var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError + if errors.As(err, &ue) { + return out, metadata, fmt.Errorf( + "This operation requests signer version(s) %v but the client only supports %v", + ue.UnsupportedSchemes, + internalauth.SupportedSchemes, + ) + } + } + + for _, authScheme := range authSchemes { + switch authScheme.(type) { + case *internalauth.AuthenticationSchemeV4: + v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4) + var signingName, signingRegion string + if v4Scheme.SigningName == nil { + signingName = "rds" + } else { + signingName = *v4Scheme.SigningName + } + if v4Scheme.SigningRegion == nil { + signingRegion = m.BuiltInResolver.(*builtInResolver).Region + } else { + signingRegion = *v4Scheme.SigningRegion + } + if v4Scheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + break + case *internalauth.AuthenticationSchemeV4A: + v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A) + if v4aScheme.SigningName == nil { + v4aScheme.SigningName = aws.String("rds") + } + if v4aScheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName) + ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0]) + break + case *internalauth.AuthenticationSchemeNone: + break + } + } + + return next.HandleSerialize(ctx, in) +} + +func addCreateIntegrationResolveEndpointMiddleware(stack *middleware.Stack, options Options) error { + return stack.Serialize.Insert(&opCreateIntegrationResolveEndpointMiddleware{ + EndpointResolver: options.EndpointResolverV2, + BuiltInResolver: &builtInResolver{ + Region: options.Region, + UseDualStack: options.EndpointOptions.UseDualStackEndpoint, + UseFIPS: options.EndpointOptions.UseFIPSEndpoint, + Endpoint: options.BaseEndpoint, + }, + }, "ResolveEndpoint", middleware.After) +} diff --git a/service/rds/api_op_DeleteCustomDBEngineVersion.go b/service/rds/api_op_DeleteCustomDBEngineVersion.go index 6953eac4be6..ff47cf08f15 100644 --- a/service/rds/api_op_DeleteCustomDBEngineVersion.go +++ b/service/rds/api_op_DeleteCustomDBEngineVersion.go @@ -173,6 +173,10 @@ type DeleteCustomDBEngineVersionOutput struct { // version. SupportsGlobalDatabases *bool + // Indicates whether the DB engine version supports Aurora zero-ETL integrations + // with Amazon Redshift. + SupportsIntegrations *bool + // Indicates whether the DB engine version supports forwarding write operations // from reader DB instances to the writer DB instance in the DB cluster. By // default, write operations aren't allowed on reader DB instances. Valid for: diff --git a/service/rds/api_op_DeleteIntegration.go b/service/rds/api_op_DeleteIntegration.go new file mode 100644 index 00000000000..911ba4cf184 --- /dev/null +++ b/service/rds/api_op_DeleteIntegration.go @@ -0,0 +1,299 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package rds + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + internalauth "github.com/aws/aws-sdk-go-v2/internal/auth" + "github.com/aws/aws-sdk-go-v2/service/rds/types" + smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" + "time" +) + +// Deletes a zero-ETL integration with Amazon Redshift. For more information, see +// Deleting Amazon Aurora zero-ETL integrations with Amazon Redshift (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/zero-etl.deleting.html) +// in the Amazon Aurora User Guide +func (c *Client) DeleteIntegration(ctx context.Context, params *DeleteIntegrationInput, optFns ...func(*Options)) (*DeleteIntegrationOutput, error) { + if params == nil { + params = &DeleteIntegrationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteIntegration", params, optFns, c.addOperationDeleteIntegrationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteIntegrationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteIntegrationInput struct { + + // The unique identifier of the integration. + // + // This member is required. + IntegrationIdentifier *string + + noSmithyDocumentSerde +} + +// An Aurora zero-ETL integration with Amazon Redshift. For more information, see +// Working with Amazon Aurora zero-ETL integrations with Amazon Redshift (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/zero-etl.html) +// in the Amazon Aurora User Guide. +type DeleteIntegrationOutput struct { + + // The encryption context for the integration. For more information, see + // Encryption context (https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) + // in the Amazon Web Services Key Management Service Developer Guide. + AdditionalEncryptionContext map[string]string + + // The time when the integration was created, in Universal Coordinated Time (UTC). + CreateTime *time.Time + + // Any errors associated with the integration. + Errors []types.IntegrationError + + // The ARN of the integration. + IntegrationArn *string + + // The name of the integration. + IntegrationName *string + + // The Amazon Web Services Key Management System (Amazon Web Services KMS) key + // identifier for the key used to to encrypt the integration. + KMSKeyId *string + + // The Amazon Resource Name (ARN) of the Aurora DB cluster used as the source for + // replication. + SourceArn *string + + // The current status of the integration. + Status types.IntegrationStatus + + // A list of tags. For more information, see Tagging Amazon RDS Resources (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) + // in the Amazon RDS User Guide. + Tags []types.Tag + + // The ARN of the Redshift data warehouse used as the target for replication. + TargetArn *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDeleteIntegrationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsquery_serializeOpDeleteIntegration{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsquery_deserializeOpDeleteIntegration{}, middleware.After) + if err != nil { + return err + } + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack, 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 = addDeleteIntegrationResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addOpDeleteIntegrationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteIntegration(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opDeleteIntegration(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "rds", + OperationName: "DeleteIntegration", + } +} + +type opDeleteIntegrationResolveEndpointMiddleware struct { + EndpointResolver EndpointResolverV2 + BuiltInResolver builtInParameterResolver +} + +func (*opDeleteIntegrationResolveEndpointMiddleware) ID() string { + return "ResolveEndpointV2" +} + +func (m *opDeleteIntegrationResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if awsmiddleware.GetRequiresLegacyEndpoints(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + if m.EndpointResolver == nil { + return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil") + } + + params := EndpointParameters{} + + m.BuiltInResolver.ResolveBuiltIns(¶ms) + + var resolvedEndpoint smithyendpoints.Endpoint + resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params) + if err != nil { + return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err) + } + + req.URL = &resolvedEndpoint.URI + + for k := range resolvedEndpoint.Headers { + req.Header.Set( + k, + resolvedEndpoint.Headers.Get(k), + ) + } + + authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties) + if err != nil { + var nfe *internalauth.NoAuthenticationSchemesFoundError + if errors.As(err, &nfe) { + // if no auth scheme is found, default to sigv4 + signingName := "rds" + signingRegion := m.BuiltInResolver.(*builtInResolver).Region + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + + } + var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError + if errors.As(err, &ue) { + return out, metadata, fmt.Errorf( + "This operation requests signer version(s) %v but the client only supports %v", + ue.UnsupportedSchemes, + internalauth.SupportedSchemes, + ) + } + } + + for _, authScheme := range authSchemes { + switch authScheme.(type) { + case *internalauth.AuthenticationSchemeV4: + v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4) + var signingName, signingRegion string + if v4Scheme.SigningName == nil { + signingName = "rds" + } else { + signingName = *v4Scheme.SigningName + } + if v4Scheme.SigningRegion == nil { + signingRegion = m.BuiltInResolver.(*builtInResolver).Region + } else { + signingRegion = *v4Scheme.SigningRegion + } + if v4Scheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + break + case *internalauth.AuthenticationSchemeV4A: + v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A) + if v4aScheme.SigningName == nil { + v4aScheme.SigningName = aws.String("rds") + } + if v4aScheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName) + ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0]) + break + case *internalauth.AuthenticationSchemeNone: + break + } + } + + return next.HandleSerialize(ctx, in) +} + +func addDeleteIntegrationResolveEndpointMiddleware(stack *middleware.Stack, options Options) error { + return stack.Serialize.Insert(&opDeleteIntegrationResolveEndpointMiddleware{ + EndpointResolver: options.EndpointResolverV2, + BuiltInResolver: &builtInResolver{ + Region: options.Region, + UseDualStack: options.EndpointOptions.UseDualStackEndpoint, + UseFIPS: options.EndpointOptions.UseFIPSEndpoint, + Endpoint: options.BaseEndpoint, + }, + }, "ResolveEndpoint", middleware.After) +} diff --git a/service/rds/api_op_DescribeIntegrations.go b/service/rds/api_op_DescribeIntegrations.go new file mode 100644 index 00000000000..b20866dd2f7 --- /dev/null +++ b/service/rds/api_op_DescribeIntegrations.go @@ -0,0 +1,373 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package rds + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + internalauth "github.com/aws/aws-sdk-go-v2/internal/auth" + "github.com/aws/aws-sdk-go-v2/service/rds/types" + smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Describe one or more zero-ETL integration with Amazon Redshift. For more +// information, see Viewing and monitoring Amazon Aurora zero-ETL integrations +// with Amazon Redshift (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/zero-etl.describingmonitoring.html) +// in the Amazon Aurora User Guide +func (c *Client) DescribeIntegrations(ctx context.Context, params *DescribeIntegrationsInput, optFns ...func(*Options)) (*DescribeIntegrationsOutput, error) { + if params == nil { + params = &DescribeIntegrationsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeIntegrations", params, optFns, c.addOperationDescribeIntegrationsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeIntegrationsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeIntegrationsInput struct { + + // A filter that specifies one or more resources to return. + Filters []types.Filter + + // The unique identifier of the integration. + IntegrationIdentifier *string + + // An optional pagination token provided by a previous DescribeIntegrations + // request. If this parameter is specified, the response includes only records + // beyond the marker, up to the value specified by MaxRecords . + Marker *string + + // The maximum number of records to include in the response. If more records exist + // than the specified MaxRecords value, a pagination token called a marker is + // included in the response so that you can retrieve the remaining results. + // Default: 100 Constraints: Minimum 20, maximum 100. + MaxRecords *int32 + + noSmithyDocumentSerde +} + +type DescribeIntegrationsOutput struct { + + // A list of integrations. + Integrations []types.Integration + + // A pagination token that can be used in a later DescribeIntegrations request. + Marker *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeIntegrationsMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsquery_serializeOpDescribeIntegrations{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsquery_deserializeOpDescribeIntegrations{}, middleware.After) + if err != nil { + return err + } + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack, 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 = addDescribeIntegrationsResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addOpDescribeIntegrationsValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeIntegrations(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + return nil +} + +// DescribeIntegrationsAPIClient is a client that implements the +// DescribeIntegrations operation. +type DescribeIntegrationsAPIClient interface { + DescribeIntegrations(context.Context, *DescribeIntegrationsInput, ...func(*Options)) (*DescribeIntegrationsOutput, error) +} + +var _ DescribeIntegrationsAPIClient = (*Client)(nil) + +// DescribeIntegrationsPaginatorOptions is the paginator options for +// DescribeIntegrations +type DescribeIntegrationsPaginatorOptions struct { + // The maximum number of records to include in the response. If more records exist + // than the specified MaxRecords value, a pagination token called a marker is + // included in the response so that you can retrieve the remaining results. + // Default: 100 Constraints: Minimum 20, maximum 100. + 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 +} + +// DescribeIntegrationsPaginator is a paginator for DescribeIntegrations +type DescribeIntegrationsPaginator struct { + options DescribeIntegrationsPaginatorOptions + client DescribeIntegrationsAPIClient + params *DescribeIntegrationsInput + nextToken *string + firstPage bool +} + +// NewDescribeIntegrationsPaginator returns a new DescribeIntegrationsPaginator +func NewDescribeIntegrationsPaginator(client DescribeIntegrationsAPIClient, params *DescribeIntegrationsInput, optFns ...func(*DescribeIntegrationsPaginatorOptions)) *DescribeIntegrationsPaginator { + if params == nil { + params = &DescribeIntegrationsInput{} + } + + options := DescribeIntegrationsPaginatorOptions{} + if params.MaxRecords != nil { + options.Limit = *params.MaxRecords + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeIntegrationsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.Marker, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeIntegrationsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeIntegrations page. +func (p *DescribeIntegrationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeIntegrationsOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.Marker = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxRecords = limit + + result, err := p.client.DescribeIntegrations(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.Marker + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +func newServiceMetadataMiddleware_opDescribeIntegrations(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "rds", + OperationName: "DescribeIntegrations", + } +} + +type opDescribeIntegrationsResolveEndpointMiddleware struct { + EndpointResolver EndpointResolverV2 + BuiltInResolver builtInParameterResolver +} + +func (*opDescribeIntegrationsResolveEndpointMiddleware) ID() string { + return "ResolveEndpointV2" +} + +func (m *opDescribeIntegrationsResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if awsmiddleware.GetRequiresLegacyEndpoints(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + if m.EndpointResolver == nil { + return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil") + } + + params := EndpointParameters{} + + m.BuiltInResolver.ResolveBuiltIns(¶ms) + + var resolvedEndpoint smithyendpoints.Endpoint + resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params) + if err != nil { + return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err) + } + + req.URL = &resolvedEndpoint.URI + + for k := range resolvedEndpoint.Headers { + req.Header.Set( + k, + resolvedEndpoint.Headers.Get(k), + ) + } + + authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties) + if err != nil { + var nfe *internalauth.NoAuthenticationSchemesFoundError + if errors.As(err, &nfe) { + // if no auth scheme is found, default to sigv4 + signingName := "rds" + signingRegion := m.BuiltInResolver.(*builtInResolver).Region + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + + } + var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError + if errors.As(err, &ue) { + return out, metadata, fmt.Errorf( + "This operation requests signer version(s) %v but the client only supports %v", + ue.UnsupportedSchemes, + internalauth.SupportedSchemes, + ) + } + } + + for _, authScheme := range authSchemes { + switch authScheme.(type) { + case *internalauth.AuthenticationSchemeV4: + v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4) + var signingName, signingRegion string + if v4Scheme.SigningName == nil { + signingName = "rds" + } else { + signingName = *v4Scheme.SigningName + } + if v4Scheme.SigningRegion == nil { + signingRegion = m.BuiltInResolver.(*builtInResolver).Region + } else { + signingRegion = *v4Scheme.SigningRegion + } + if v4Scheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + break + case *internalauth.AuthenticationSchemeV4A: + v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A) + if v4aScheme.SigningName == nil { + v4aScheme.SigningName = aws.String("rds") + } + if v4aScheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName) + ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0]) + break + case *internalauth.AuthenticationSchemeNone: + break + } + } + + return next.HandleSerialize(ctx, in) +} + +func addDescribeIntegrationsResolveEndpointMiddleware(stack *middleware.Stack, options Options) error { + return stack.Serialize.Insert(&opDescribeIntegrationsResolveEndpointMiddleware{ + EndpointResolver: options.EndpointResolverV2, + BuiltInResolver: &builtInResolver{ + Region: options.Region, + UseDualStack: options.EndpointOptions.UseDualStackEndpoint, + UseFIPS: options.EndpointOptions.UseFIPSEndpoint, + Endpoint: options.BaseEndpoint, + }, + }, "ResolveEndpoint", middleware.After) +} diff --git a/service/rds/api_op_ModifyCustomDBEngineVersion.go b/service/rds/api_op_ModifyCustomDBEngineVersion.go index 7d5b3a9efe5..c2f77add138 100644 --- a/service/rds/api_op_ModifyCustomDBEngineVersion.go +++ b/service/rds/api_op_ModifyCustomDBEngineVersion.go @@ -183,6 +183,10 @@ type ModifyCustomDBEngineVersionOutput struct { // version. SupportsGlobalDatabases *bool + // Indicates whether the DB engine version supports Aurora zero-ETL integrations + // with Amazon Redshift. + SupportsIntegrations *bool + // Indicates whether the DB engine version supports forwarding write operations // from reader DB instances to the writer DB instance in the DB cluster. By // default, write operations aren't allowed on reader DB instances. Valid for: diff --git a/service/rds/deserializers.go b/service/rds/deserializers.go index 102e076565a..f731abd1b77 100644 --- a/service/rds/deserializers.go +++ b/service/rds/deserializers.go @@ -376,6 +376,9 @@ func awsAwsquery_deserializeOpErrorAddTagsToResource(response *smithyhttp.Respon case strings.EqualFold("DBSnapshotNotFound", errorCode): return awsAwsquery_deserializeErrorDBSnapshotNotFoundFault(response, errorBody) + case strings.EqualFold("IntegrationNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorIntegrationNotFoundFault(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -3476,14 +3479,14 @@ func awsAwsquery_deserializeOpErrorCreateGlobalCluster(response *smithyhttp.Resp } } -type awsAwsquery_deserializeOpCreateOptionGroup struct { +type awsAwsquery_deserializeOpCreateIntegration struct { } -func (*awsAwsquery_deserializeOpCreateOptionGroup) ID() string { +func (*awsAwsquery_deserializeOpCreateIntegration) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpCreateOptionGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpCreateIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3497,9 +3500,9 @@ func (m *awsAwsquery_deserializeOpCreateOptionGroup) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorCreateOptionGroup(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorCreateIntegration(response, &metadata) } - output := &CreateOptionGroupOutput{} + output := &CreateIntegrationOutput{} out.Result = output var buff [1024]byte @@ -3520,7 +3523,7 @@ func (m *awsAwsquery_deserializeOpCreateOptionGroup) HandleDeserialize(ctx conte } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("CreateOptionGroupResult") + t, err = decoder.GetElement("CreateIntegrationResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3532,7 +3535,7 @@ func (m *awsAwsquery_deserializeOpCreateOptionGroup) HandleDeserialize(ctx conte } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentCreateOptionGroupOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentCreateIntegrationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3546,7 +3549,7 @@ func (m *awsAwsquery_deserializeOpCreateOptionGroup) HandleDeserialize(ctx conte return out, metadata, err } -func awsAwsquery_deserializeOpErrorCreateOptionGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorCreateIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -3571,11 +3574,23 @@ func awsAwsquery_deserializeOpErrorCreateOptionGroup(response *smithyhttp.Respon } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("OptionGroupAlreadyExistsFault", errorCode): - return awsAwsquery_deserializeErrorOptionGroupAlreadyExistsFault(response, errorBody) + case strings.EqualFold("DBClusterNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) - case strings.EqualFold("OptionGroupQuotaExceededFault", errorCode): - return awsAwsquery_deserializeErrorOptionGroupQuotaExceededFault(response, errorBody) + case strings.EqualFold("DBInstanceNotFound", errorCode): + return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) + + case strings.EqualFold("IntegrationAlreadyExistsFault", errorCode): + return awsAwsquery_deserializeErrorIntegrationAlreadyExistsFault(response, errorBody) + + case strings.EqualFold("IntegrationConflictOperationFault", errorCode): + return awsAwsquery_deserializeErrorIntegrationConflictOperationFault(response, errorBody) + + case strings.EqualFold("IntegrationQuotaExceededFault", errorCode): + return awsAwsquery_deserializeErrorIntegrationQuotaExceededFault(response, errorBody) + + case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): + return awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -3587,14 +3602,14 @@ func awsAwsquery_deserializeOpErrorCreateOptionGroup(response *smithyhttp.Respon } } -type awsAwsquery_deserializeOpDeleteBlueGreenDeployment struct { +type awsAwsquery_deserializeOpCreateOptionGroup struct { } -func (*awsAwsquery_deserializeOpDeleteBlueGreenDeployment) ID() string { +func (*awsAwsquery_deserializeOpCreateOptionGroup) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDeleteBlueGreenDeployment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpCreateOptionGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3608,9 +3623,9 @@ func (m *awsAwsquery_deserializeOpDeleteBlueGreenDeployment) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDeleteBlueGreenDeployment(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorCreateOptionGroup(response, &metadata) } - output := &DeleteBlueGreenDeploymentOutput{} + output := &CreateOptionGroupOutput{} out.Result = output var buff [1024]byte @@ -3631,7 +3646,7 @@ func (m *awsAwsquery_deserializeOpDeleteBlueGreenDeployment) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DeleteBlueGreenDeploymentResult") + t, err = decoder.GetElement("CreateOptionGroupResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3643,7 +3658,7 @@ func (m *awsAwsquery_deserializeOpDeleteBlueGreenDeployment) HandleDeserialize(c } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDeleteBlueGreenDeploymentOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentCreateOptionGroupOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3657,7 +3672,7 @@ func (m *awsAwsquery_deserializeOpDeleteBlueGreenDeployment) HandleDeserialize(c return out, metadata, err } -func awsAwsquery_deserializeOpErrorDeleteBlueGreenDeployment(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorCreateOptionGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -3682,11 +3697,11 @@ func awsAwsquery_deserializeOpErrorDeleteBlueGreenDeployment(response *smithyhtt } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("BlueGreenDeploymentNotFoundFault", errorCode): - return awsAwsquery_deserializeErrorBlueGreenDeploymentNotFoundFault(response, errorBody) + case strings.EqualFold("OptionGroupAlreadyExistsFault", errorCode): + return awsAwsquery_deserializeErrorOptionGroupAlreadyExistsFault(response, errorBody) - case strings.EqualFold("InvalidBlueGreenDeploymentStateFault", errorCode): - return awsAwsquery_deserializeErrorInvalidBlueGreenDeploymentStateFault(response, errorBody) + case strings.EqualFold("OptionGroupQuotaExceededFault", errorCode): + return awsAwsquery_deserializeErrorOptionGroupQuotaExceededFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -3698,14 +3713,14 @@ func awsAwsquery_deserializeOpErrorDeleteBlueGreenDeployment(response *smithyhtt } } -type awsAwsquery_deserializeOpDeleteCustomDBEngineVersion struct { +type awsAwsquery_deserializeOpDeleteBlueGreenDeployment struct { } -func (*awsAwsquery_deserializeOpDeleteCustomDBEngineVersion) ID() string { +func (*awsAwsquery_deserializeOpDeleteBlueGreenDeployment) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDeleteCustomDBEngineVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDeleteBlueGreenDeployment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3719,9 +3734,9 @@ func (m *awsAwsquery_deserializeOpDeleteCustomDBEngineVersion) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDeleteCustomDBEngineVersion(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDeleteBlueGreenDeployment(response, &metadata) } - output := &DeleteCustomDBEngineVersionOutput{} + output := &DeleteBlueGreenDeploymentOutput{} out.Result = output var buff [1024]byte @@ -3742,7 +3757,7 @@ func (m *awsAwsquery_deserializeOpDeleteCustomDBEngineVersion) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DeleteCustomDBEngineVersionResult") + t, err = decoder.GetElement("DeleteBlueGreenDeploymentResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3754,7 +3769,7 @@ func (m *awsAwsquery_deserializeOpDeleteCustomDBEngineVersion) HandleDeserialize } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDeleteCustomDBEngineVersionOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDeleteBlueGreenDeploymentOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3768,7 +3783,7 @@ func (m *awsAwsquery_deserializeOpDeleteCustomDBEngineVersion) HandleDeserialize return out, metadata, err } -func awsAwsquery_deserializeOpErrorDeleteCustomDBEngineVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDeleteBlueGreenDeployment(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -3793,11 +3808,11 @@ func awsAwsquery_deserializeOpErrorDeleteCustomDBEngineVersion(response *smithyh } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("CustomDBEngineVersionNotFoundFault", errorCode): - return awsAwsquery_deserializeErrorCustomDBEngineVersionNotFoundFault(response, errorBody) + case strings.EqualFold("BlueGreenDeploymentNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorBlueGreenDeploymentNotFoundFault(response, errorBody) - case strings.EqualFold("InvalidCustomDBEngineVersionStateFault", errorCode): - return awsAwsquery_deserializeErrorInvalidCustomDBEngineVersionStateFault(response, errorBody) + case strings.EqualFold("InvalidBlueGreenDeploymentStateFault", errorCode): + return awsAwsquery_deserializeErrorInvalidBlueGreenDeploymentStateFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -3809,14 +3824,14 @@ func awsAwsquery_deserializeOpErrorDeleteCustomDBEngineVersion(response *smithyh } } -type awsAwsquery_deserializeOpDeleteDBCluster struct { +type awsAwsquery_deserializeOpDeleteCustomDBEngineVersion struct { } -func (*awsAwsquery_deserializeOpDeleteDBCluster) ID() string { +func (*awsAwsquery_deserializeOpDeleteCustomDBEngineVersion) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDeleteDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDeleteCustomDBEngineVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3830,9 +3845,9 @@ func (m *awsAwsquery_deserializeOpDeleteDBCluster) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBCluster(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDeleteCustomDBEngineVersion(response, &metadata) } - output := &DeleteDBClusterOutput{} + output := &DeleteCustomDBEngineVersionOutput{} out.Result = output var buff [1024]byte @@ -3853,7 +3868,7 @@ func (m *awsAwsquery_deserializeOpDeleteDBCluster) HandleDeserialize(ctx context } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DeleteDBClusterResult") + t, err = decoder.GetElement("DeleteCustomDBEngineVersionResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3865,7 +3880,7 @@ func (m *awsAwsquery_deserializeOpDeleteDBCluster) HandleDeserialize(ctx context } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDeleteDBClusterOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDeleteCustomDBEngineVersionOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3879,7 +3894,7 @@ func (m *awsAwsquery_deserializeOpDeleteDBCluster) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsquery_deserializeOpErrorDeleteDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDeleteCustomDBEngineVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -3904,23 +3919,11 @@ func awsAwsquery_deserializeOpErrorDeleteDBCluster(response *smithyhttp.Response } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("DBClusterAutomatedBackupQuotaExceededFault", errorCode): - return awsAwsquery_deserializeErrorDBClusterAutomatedBackupQuotaExceededFault(response, errorBody) - - case strings.EqualFold("DBClusterNotFoundFault", errorCode): - return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) - - case strings.EqualFold("DBClusterSnapshotAlreadyExistsFault", errorCode): - return awsAwsquery_deserializeErrorDBClusterSnapshotAlreadyExistsFault(response, errorBody) - - case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): - return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) - - case strings.EqualFold("InvalidDBClusterStateFault", errorCode): - return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) + case strings.EqualFold("CustomDBEngineVersionNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorCustomDBEngineVersionNotFoundFault(response, errorBody) - case strings.EqualFold("SnapshotQuotaExceeded", errorCode): - return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody) + case strings.EqualFold("InvalidCustomDBEngineVersionStateFault", errorCode): + return awsAwsquery_deserializeErrorInvalidCustomDBEngineVersionStateFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -3932,14 +3935,14 @@ func awsAwsquery_deserializeOpErrorDeleteDBCluster(response *smithyhttp.Response } } -type awsAwsquery_deserializeOpDeleteDBClusterAutomatedBackup struct { +type awsAwsquery_deserializeOpDeleteDBCluster struct { } -func (*awsAwsquery_deserializeOpDeleteDBClusterAutomatedBackup) ID() string { +func (*awsAwsquery_deserializeOpDeleteDBCluster) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDeleteDBClusterAutomatedBackup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDeleteDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -3953,9 +3956,9 @@ func (m *awsAwsquery_deserializeOpDeleteDBClusterAutomatedBackup) HandleDeserial } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterAutomatedBackup(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBCluster(response, &metadata) } - output := &DeleteDBClusterAutomatedBackupOutput{} + output := &DeleteDBClusterOutput{} out.Result = output var buff [1024]byte @@ -3976,7 +3979,7 @@ func (m *awsAwsquery_deserializeOpDeleteDBClusterAutomatedBackup) HandleDeserial } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DeleteDBClusterAutomatedBackupResult") + t, err = decoder.GetElement("DeleteDBClusterResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -3988,7 +3991,7 @@ func (m *awsAwsquery_deserializeOpDeleteDBClusterAutomatedBackup) HandleDeserial } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDeleteDBClusterAutomatedBackupOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDeleteDBClusterOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4002,7 +4005,7 @@ func (m *awsAwsquery_deserializeOpDeleteDBClusterAutomatedBackup) HandleDeserial return out, metadata, err } -func awsAwsquery_deserializeOpErrorDeleteDBClusterAutomatedBackup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDeleteDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4027,11 +4030,23 @@ func awsAwsquery_deserializeOpErrorDeleteDBClusterAutomatedBackup(response *smit } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("DBClusterAutomatedBackupNotFoundFault", errorCode): - return awsAwsquery_deserializeErrorDBClusterAutomatedBackupNotFoundFault(response, errorBody) + case strings.EqualFold("DBClusterAutomatedBackupQuotaExceededFault", errorCode): + return awsAwsquery_deserializeErrorDBClusterAutomatedBackupQuotaExceededFault(response, errorBody) - case strings.EqualFold("InvalidDBClusterAutomatedBackupStateFault", errorCode): - return awsAwsquery_deserializeErrorInvalidDBClusterAutomatedBackupStateFault(response, errorBody) + case strings.EqualFold("DBClusterNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) + + case strings.EqualFold("DBClusterSnapshotAlreadyExistsFault", errorCode): + return awsAwsquery_deserializeErrorDBClusterSnapshotAlreadyExistsFault(response, errorBody) + + case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): + return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) + + case strings.EqualFold("InvalidDBClusterStateFault", errorCode): + return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) + + case strings.EqualFold("SnapshotQuotaExceeded", errorCode): + return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -4043,14 +4058,14 @@ func awsAwsquery_deserializeOpErrorDeleteDBClusterAutomatedBackup(response *smit } } -type awsAwsquery_deserializeOpDeleteDBClusterEndpoint struct { +type awsAwsquery_deserializeOpDeleteDBClusterAutomatedBackup struct { } -func (*awsAwsquery_deserializeOpDeleteDBClusterEndpoint) ID() string { +func (*awsAwsquery_deserializeOpDeleteDBClusterAutomatedBackup) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDeleteDBClusterEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDeleteDBClusterAutomatedBackup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4064,9 +4079,9 @@ func (m *awsAwsquery_deserializeOpDeleteDBClusterEndpoint) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterEndpoint(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterAutomatedBackup(response, &metadata) } - output := &DeleteDBClusterEndpointOutput{} + output := &DeleteDBClusterAutomatedBackupOutput{} out.Result = output var buff [1024]byte @@ -4087,7 +4102,7 @@ func (m *awsAwsquery_deserializeOpDeleteDBClusterEndpoint) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DeleteDBClusterEndpointResult") + t, err = decoder.GetElement("DeleteDBClusterAutomatedBackupResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4099,7 +4114,7 @@ func (m *awsAwsquery_deserializeOpDeleteDBClusterEndpoint) HandleDeserialize(ctx } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDeleteDBClusterEndpointOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDeleteDBClusterAutomatedBackupOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4113,86 +4128,7 @@ func (m *awsAwsquery_deserializeOpDeleteDBClusterEndpoint) HandleDeserialize(ctx return out, metadata, err } -func awsAwsquery_deserializeOpErrorDeleteDBClusterEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) - if err != nil { - return err - } - if reqID := errorComponents.RequestID; len(reqID) != 0 { - awsmiddleware.SetRequestIDMetadata(metadata, reqID) - } - if len(errorComponents.Code) != 0 { - errorCode = errorComponents.Code - } - if len(errorComponents.Message) != 0 { - errorMessage = errorComponents.Message - } - errorBody.Seek(0, io.SeekStart) - switch { - case strings.EqualFold("DBClusterEndpointNotFoundFault", errorCode): - return awsAwsquery_deserializeErrorDBClusterEndpointNotFoundFault(response, errorBody) - - case strings.EqualFold("InvalidDBClusterEndpointStateFault", errorCode): - return awsAwsquery_deserializeErrorInvalidDBClusterEndpointStateFault(response, errorBody) - - case strings.EqualFold("InvalidDBClusterStateFault", errorCode): - return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsquery_deserializeOpDeleteDBClusterParameterGroup struct { -} - -func (*awsAwsquery_deserializeOpDeleteDBClusterParameterGroup) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsquery_deserializeOpDeleteDBClusterParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterParameterGroup(response, &metadata) - } - output := &DeleteDBClusterParameterGroupOutput{} - 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 awsAwsquery_deserializeOpErrorDeleteDBClusterParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDeleteDBClusterAutomatedBackup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4217,11 +4153,11 @@ func awsAwsquery_deserializeOpErrorDeleteDBClusterParameterGroup(response *smith } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("DBParameterGroupNotFound", errorCode): - return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) + case strings.EqualFold("DBClusterAutomatedBackupNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorDBClusterAutomatedBackupNotFoundFault(response, errorBody) - case strings.EqualFold("InvalidDBParameterGroupState", errorCode): - return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) + case strings.EqualFold("InvalidDBClusterAutomatedBackupStateFault", errorCode): + return awsAwsquery_deserializeErrorInvalidDBClusterAutomatedBackupStateFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -4233,14 +4169,14 @@ func awsAwsquery_deserializeOpErrorDeleteDBClusterParameterGroup(response *smith } } -type awsAwsquery_deserializeOpDeleteDBClusterSnapshot struct { +type awsAwsquery_deserializeOpDeleteDBClusterEndpoint struct { } -func (*awsAwsquery_deserializeOpDeleteDBClusterSnapshot) ID() string { +func (*awsAwsquery_deserializeOpDeleteDBClusterEndpoint) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDeleteDBClusterSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDeleteDBClusterEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4254,9 +4190,9 @@ func (m *awsAwsquery_deserializeOpDeleteDBClusterSnapshot) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterSnapshot(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterEndpoint(response, &metadata) } - output := &DeleteDBClusterSnapshotOutput{} + output := &DeleteDBClusterEndpointOutput{} out.Result = output var buff [1024]byte @@ -4277,7 +4213,7 @@ func (m *awsAwsquery_deserializeOpDeleteDBClusterSnapshot) HandleDeserialize(ctx } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DeleteDBClusterSnapshotResult") + t, err = decoder.GetElement("DeleteDBClusterEndpointResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4289,7 +4225,7 @@ func (m *awsAwsquery_deserializeOpDeleteDBClusterSnapshot) HandleDeserialize(ctx } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDeleteDBClusterSnapshotOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDeleteDBClusterEndpointOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4303,7 +4239,197 @@ func (m *awsAwsquery_deserializeOpDeleteDBClusterSnapshot) HandleDeserialize(ctx return out, metadata, err } -func awsAwsquery_deserializeOpErrorDeleteDBClusterSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDeleteDBClusterEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) + if err != nil { + return err + } + if reqID := errorComponents.RequestID; len(reqID) != 0 { + awsmiddleware.SetRequestIDMetadata(metadata, reqID) + } + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + case strings.EqualFold("DBClusterEndpointNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorDBClusterEndpointNotFoundFault(response, errorBody) + + case strings.EqualFold("InvalidDBClusterEndpointStateFault", errorCode): + return awsAwsquery_deserializeErrorInvalidDBClusterEndpointStateFault(response, errorBody) + + case strings.EqualFold("InvalidDBClusterStateFault", errorCode): + return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsquery_deserializeOpDeleteDBClusterParameterGroup struct { +} + +func (*awsAwsquery_deserializeOpDeleteDBClusterParameterGroup) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsquery_deserializeOpDeleteDBClusterParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterParameterGroup(response, &metadata) + } + output := &DeleteDBClusterParameterGroupOutput{} + 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 awsAwsquery_deserializeOpErrorDeleteDBClusterParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) + if err != nil { + return err + } + if reqID := errorComponents.RequestID; len(reqID) != 0 { + awsmiddleware.SetRequestIDMetadata(metadata, reqID) + } + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + case strings.EqualFold("DBParameterGroupNotFound", errorCode): + return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) + + case strings.EqualFold("InvalidDBParameterGroupState", errorCode): + return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsquery_deserializeOpDeleteDBClusterSnapshot struct { +} + +func (*awsAwsquery_deserializeOpDeleteDBClusterSnapshot) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsquery_deserializeOpDeleteDBClusterSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterSnapshot(response, &metadata) + } + output := &DeleteDBClusterSnapshotOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("DeleteDBClusterSnapshotResult") + if err != nil { + var 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 + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeOpDocumentDeleteDBClusterSnapshotOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsquery_deserializeOpErrorDeleteDBClusterSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5364,14 +5490,14 @@ func awsAwsquery_deserializeOpErrorDeleteGlobalCluster(response *smithyhttp.Resp } } -type awsAwsquery_deserializeOpDeleteOptionGroup struct { +type awsAwsquery_deserializeOpDeleteIntegration struct { } -func (*awsAwsquery_deserializeOpDeleteOptionGroup) ID() string { +func (*awsAwsquery_deserializeOpDeleteIntegration) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDeleteOptionGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDeleteIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5385,85 +5511,9 @@ func (m *awsAwsquery_deserializeOpDeleteOptionGroup) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDeleteOptionGroup(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDeleteIntegration(response, &metadata) } - output := &DeleteOptionGroupOutput{} - 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 awsAwsquery_deserializeOpErrorDeleteOptionGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { - var errorBuffer bytes.Buffer - if _, err := io.Copy(&errorBuffer, response.Body); err != nil { - return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} - } - errorBody := bytes.NewReader(errorBuffer.Bytes()) - - errorCode := "UnknownError" - errorMessage := errorCode - - errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) - if err != nil { - return err - } - if reqID := errorComponents.RequestID; len(reqID) != 0 { - awsmiddleware.SetRequestIDMetadata(metadata, reqID) - } - if len(errorComponents.Code) != 0 { - errorCode = errorComponents.Code - } - if len(errorComponents.Message) != 0 { - errorMessage = errorComponents.Message - } - errorBody.Seek(0, io.SeekStart) - switch { - case strings.EqualFold("InvalidOptionGroupStateFault", errorCode): - return awsAwsquery_deserializeErrorInvalidOptionGroupStateFault(response, errorBody) - - case strings.EqualFold("OptionGroupNotFoundFault", errorCode): - return awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response, errorBody) - - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, - } - return genericError - - } -} - -type awsAwsquery_deserializeOpDeregisterDBProxyTargets struct { -} - -func (*awsAwsquery_deserializeOpDeregisterDBProxyTargets) ID() string { - return "OperationDeserializer" -} - -func (m *awsAwsquery_deserializeOpDeregisterDBProxyTargets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( - out middleware.DeserializeOutput, metadata middleware.Metadata, err error, -) { - out, metadata, err = next.HandleDeserialize(ctx, in) - if err != nil { - return out, metadata, err - } - - response, ok := out.RawResponse.(*smithyhttp.Response) - if !ok { - return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} - } - - if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDeregisterDBProxyTargets(response, &metadata) - } - output := &DeregisterDBProxyTargetsOutput{} + output := &DeleteIntegrationOutput{} out.Result = output var buff [1024]byte @@ -5484,7 +5534,7 @@ func (m *awsAwsquery_deserializeOpDeregisterDBProxyTargets) HandleDeserialize(ct } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DeregisterDBProxyTargetsResult") + t, err = decoder.GetElement("DeleteIntegrationResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5496,7 +5546,7 @@ func (m *awsAwsquery_deserializeOpDeregisterDBProxyTargets) HandleDeserialize(ct } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDeregisterDBProxyTargetsOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDeleteIntegrationOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5510,7 +5560,7 @@ func (m *awsAwsquery_deserializeOpDeregisterDBProxyTargets) HandleDeserialize(ct return out, metadata, err } -func awsAwsquery_deserializeOpErrorDeregisterDBProxyTargets(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDeleteIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5535,17 +5585,90 @@ func awsAwsquery_deserializeOpErrorDeregisterDBProxyTargets(response *smithyhttp } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("DBProxyNotFoundFault", errorCode): - return awsAwsquery_deserializeErrorDBProxyNotFoundFault(response, errorBody) + case strings.EqualFold("IntegrationConflictOperationFault", errorCode): + return awsAwsquery_deserializeErrorIntegrationConflictOperationFault(response, errorBody) - case strings.EqualFold("DBProxyTargetGroupNotFoundFault", errorCode): - return awsAwsquery_deserializeErrorDBProxyTargetGroupNotFoundFault(response, errorBody) + case strings.EqualFold("IntegrationNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorIntegrationNotFoundFault(response, errorBody) - case strings.EqualFold("DBProxyTargetNotFoundFault", errorCode): - return awsAwsquery_deserializeErrorDBProxyTargetNotFoundFault(response, errorBody) + case strings.EqualFold("InvalidIntegrationStateFault", errorCode): + return awsAwsquery_deserializeErrorInvalidIntegrationStateFault(response, errorBody) - case strings.EqualFold("InvalidDBProxyStateFault", errorCode): - return awsAwsquery_deserializeErrorInvalidDBProxyStateFault(response, errorBody) + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsquery_deserializeOpDeleteOptionGroup struct { +} + +func (*awsAwsquery_deserializeOpDeleteOptionGroup) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsquery_deserializeOpDeleteOptionGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsquery_deserializeOpErrorDeleteOptionGroup(response, &metadata) + } + output := &DeleteOptionGroupOutput{} + 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 awsAwsquery_deserializeOpErrorDeleteOptionGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) + if err != nil { + return err + } + if reqID := errorComponents.RequestID; len(reqID) != 0 { + awsmiddleware.SetRequestIDMetadata(metadata, reqID) + } + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + case strings.EqualFold("InvalidOptionGroupStateFault", errorCode): + return awsAwsquery_deserializeErrorInvalidOptionGroupStateFault(response, errorBody) + + case strings.EqualFold("OptionGroupNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -5557,14 +5680,14 @@ func awsAwsquery_deserializeOpErrorDeregisterDBProxyTargets(response *smithyhttp } } -type awsAwsquery_deserializeOpDescribeAccountAttributes struct { +type awsAwsquery_deserializeOpDeregisterDBProxyTargets struct { } -func (*awsAwsquery_deserializeOpDescribeAccountAttributes) ID() string { +func (*awsAwsquery_deserializeOpDeregisterDBProxyTargets) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeAccountAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDeregisterDBProxyTargets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5578,9 +5701,9 @@ func (m *awsAwsquery_deserializeOpDescribeAccountAttributes) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeAccountAttributes(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDeregisterDBProxyTargets(response, &metadata) } - output := &DescribeAccountAttributesOutput{} + output := &DeregisterDBProxyTargetsOutput{} out.Result = output var buff [1024]byte @@ -5601,7 +5724,7 @@ func (m *awsAwsquery_deserializeOpDescribeAccountAttributes) HandleDeserialize(c } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeAccountAttributesResult") + t, err = decoder.GetElement("DeregisterDBProxyTargetsResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5613,7 +5736,7 @@ func (m *awsAwsquery_deserializeOpDescribeAccountAttributes) HandleDeserialize(c } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeAccountAttributesOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDeregisterDBProxyTargetsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5627,7 +5750,7 @@ func (m *awsAwsquery_deserializeOpDescribeAccountAttributes) HandleDeserialize(c return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeAccountAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDeregisterDBProxyTargets(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5652,6 +5775,18 @@ func awsAwsquery_deserializeOpErrorDescribeAccountAttributes(response *smithyhtt } errorBody.Seek(0, io.SeekStart) switch { + case strings.EqualFold("DBProxyNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorDBProxyNotFoundFault(response, errorBody) + + case strings.EqualFold("DBProxyTargetGroupNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorDBProxyTargetGroupNotFoundFault(response, errorBody) + + case strings.EqualFold("DBProxyTargetNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorDBProxyTargetNotFoundFault(response, errorBody) + + case strings.EqualFold("InvalidDBProxyStateFault", errorCode): + return awsAwsquery_deserializeErrorInvalidDBProxyStateFault(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -5662,14 +5797,14 @@ func awsAwsquery_deserializeOpErrorDescribeAccountAttributes(response *smithyhtt } } -type awsAwsquery_deserializeOpDescribeBlueGreenDeployments struct { +type awsAwsquery_deserializeOpDescribeAccountAttributes struct { } -func (*awsAwsquery_deserializeOpDescribeBlueGreenDeployments) ID() string { +func (*awsAwsquery_deserializeOpDescribeAccountAttributes) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeBlueGreenDeployments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDescribeAccountAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5683,9 +5818,9 @@ func (m *awsAwsquery_deserializeOpDescribeBlueGreenDeployments) HandleDeserializ } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeBlueGreenDeployments(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDescribeAccountAttributes(response, &metadata) } - output := &DescribeBlueGreenDeploymentsOutput{} + output := &DescribeAccountAttributesOutput{} out.Result = output var buff [1024]byte @@ -5706,7 +5841,7 @@ func (m *awsAwsquery_deserializeOpDescribeBlueGreenDeployments) HandleDeserializ } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeBlueGreenDeploymentsResult") + t, err = decoder.GetElement("DescribeAccountAttributesResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5718,7 +5853,7 @@ func (m *awsAwsquery_deserializeOpDescribeBlueGreenDeployments) HandleDeserializ } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeBlueGreenDeploymentsOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDescribeAccountAttributesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5732,7 +5867,7 @@ func (m *awsAwsquery_deserializeOpDescribeBlueGreenDeployments) HandleDeserializ return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeBlueGreenDeployments(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDescribeAccountAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5757,9 +5892,6 @@ func awsAwsquery_deserializeOpErrorDescribeBlueGreenDeployments(response *smithy } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("BlueGreenDeploymentNotFoundFault", errorCode): - return awsAwsquery_deserializeErrorBlueGreenDeploymentNotFoundFault(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -5770,14 +5902,14 @@ func awsAwsquery_deserializeOpErrorDescribeBlueGreenDeployments(response *smithy } } -type awsAwsquery_deserializeOpDescribeCertificates struct { +type awsAwsquery_deserializeOpDescribeBlueGreenDeployments struct { } -func (*awsAwsquery_deserializeOpDescribeCertificates) ID() string { +func (*awsAwsquery_deserializeOpDescribeBlueGreenDeployments) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeCertificates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDescribeBlueGreenDeployments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5791,9 +5923,9 @@ func (m *awsAwsquery_deserializeOpDescribeCertificates) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeCertificates(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDescribeBlueGreenDeployments(response, &metadata) } - output := &DescribeCertificatesOutput{} + output := &DescribeBlueGreenDeploymentsOutput{} out.Result = output var buff [1024]byte @@ -5814,7 +5946,7 @@ func (m *awsAwsquery_deserializeOpDescribeCertificates) HandleDeserialize(ctx co } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeCertificatesResult") + t, err = decoder.GetElement("DescribeBlueGreenDeploymentsResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5826,7 +5958,7 @@ func (m *awsAwsquery_deserializeOpDescribeCertificates) HandleDeserialize(ctx co } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeCertificatesOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDescribeBlueGreenDeploymentsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5840,7 +5972,7 @@ func (m *awsAwsquery_deserializeOpDescribeCertificates) HandleDeserialize(ctx co return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeCertificates(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDescribeBlueGreenDeployments(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5865,8 +5997,8 @@ func awsAwsquery_deserializeOpErrorDescribeCertificates(response *smithyhttp.Res } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("CertificateNotFound", errorCode): - return awsAwsquery_deserializeErrorCertificateNotFoundFault(response, errorBody) + case strings.EqualFold("BlueGreenDeploymentNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorBlueGreenDeploymentNotFoundFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -5878,14 +6010,14 @@ func awsAwsquery_deserializeOpErrorDescribeCertificates(response *smithyhttp.Res } } -type awsAwsquery_deserializeOpDescribeDBClusterAutomatedBackups struct { +type awsAwsquery_deserializeOpDescribeCertificates struct { } -func (*awsAwsquery_deserializeOpDescribeDBClusterAutomatedBackups) ID() string { +func (*awsAwsquery_deserializeOpDescribeCertificates) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeDBClusterAutomatedBackups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDescribeCertificates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5899,9 +6031,9 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterAutomatedBackups) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterAutomatedBackups(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDescribeCertificates(response, &metadata) } - output := &DescribeDBClusterAutomatedBackupsOutput{} + output := &DescribeCertificatesOutput{} out.Result = output var buff [1024]byte @@ -5922,7 +6054,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterAutomatedBackups) HandleDeser } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeDBClusterAutomatedBackupsResult") + t, err = decoder.GetElement("DescribeCertificatesResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5934,7 +6066,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterAutomatedBackups) HandleDeser } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeDBClusterAutomatedBackupsOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDescribeCertificatesOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5948,7 +6080,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterAutomatedBackups) HandleDeser return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeDBClusterAutomatedBackups(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDescribeCertificates(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5973,8 +6105,8 @@ func awsAwsquery_deserializeOpErrorDescribeDBClusterAutomatedBackups(response *s } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("DBClusterAutomatedBackupNotFoundFault", errorCode): - return awsAwsquery_deserializeErrorDBClusterAutomatedBackupNotFoundFault(response, errorBody) + case strings.EqualFold("CertificateNotFound", errorCode): + return awsAwsquery_deserializeErrorCertificateNotFoundFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -5986,14 +6118,14 @@ func awsAwsquery_deserializeOpErrorDescribeDBClusterAutomatedBackups(response *s } } -type awsAwsquery_deserializeOpDescribeDBClusterBacktracks struct { +type awsAwsquery_deserializeOpDescribeDBClusterAutomatedBackups struct { } -func (*awsAwsquery_deserializeOpDescribeDBClusterBacktracks) ID() string { +func (*awsAwsquery_deserializeOpDescribeDBClusterAutomatedBackups) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeDBClusterBacktracks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDescribeDBClusterAutomatedBackups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6007,9 +6139,9 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterBacktracks) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterBacktracks(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterAutomatedBackups(response, &metadata) } - output := &DescribeDBClusterBacktracksOutput{} + output := &DescribeDBClusterAutomatedBackupsOutput{} out.Result = output var buff [1024]byte @@ -6030,7 +6162,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterBacktracks) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeDBClusterBacktracksResult") + t, err = decoder.GetElement("DescribeDBClusterAutomatedBackupsResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6042,7 +6174,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterBacktracks) HandleDeserialize } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeDBClusterBacktracksOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDescribeDBClusterAutomatedBackupsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6056,7 +6188,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterBacktracks) HandleDeserialize return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeDBClusterBacktracks(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDescribeDBClusterAutomatedBackups(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6081,11 +6213,8 @@ func awsAwsquery_deserializeOpErrorDescribeDBClusterBacktracks(response *smithyh } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("DBClusterBacktrackNotFoundFault", errorCode): - return awsAwsquery_deserializeErrorDBClusterBacktrackNotFoundFault(response, errorBody) - - case strings.EqualFold("DBClusterNotFoundFault", errorCode): - return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) + case strings.EqualFold("DBClusterAutomatedBackupNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorDBClusterAutomatedBackupNotFoundFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -6097,14 +6226,14 @@ func awsAwsquery_deserializeOpErrorDescribeDBClusterBacktracks(response *smithyh } } -type awsAwsquery_deserializeOpDescribeDBClusterEndpoints struct { +type awsAwsquery_deserializeOpDescribeDBClusterBacktracks struct { } -func (*awsAwsquery_deserializeOpDescribeDBClusterEndpoints) ID() string { +func (*awsAwsquery_deserializeOpDescribeDBClusterBacktracks) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeDBClusterEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDescribeDBClusterBacktracks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6118,9 +6247,9 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterEndpoints) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterEndpoints(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterBacktracks(response, &metadata) } - output := &DescribeDBClusterEndpointsOutput{} + output := &DescribeDBClusterBacktracksOutput{} out.Result = output var buff [1024]byte @@ -6141,7 +6270,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterEndpoints) HandleDeserialize( } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeDBClusterEndpointsResult") + t, err = decoder.GetElement("DescribeDBClusterBacktracksResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6153,7 +6282,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterEndpoints) HandleDeserialize( } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeDBClusterEndpointsOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDescribeDBClusterBacktracksOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6167,7 +6296,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterEndpoints) HandleDeserialize( return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeDBClusterEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDescribeDBClusterBacktracks(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6192,6 +6321,9 @@ func awsAwsquery_deserializeOpErrorDescribeDBClusterEndpoints(response *smithyht } errorBody.Seek(0, io.SeekStart) switch { + case strings.EqualFold("DBClusterBacktrackNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorDBClusterBacktrackNotFoundFault(response, errorBody) + case strings.EqualFold("DBClusterNotFoundFault", errorCode): return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) @@ -6205,14 +6337,14 @@ func awsAwsquery_deserializeOpErrorDescribeDBClusterEndpoints(response *smithyht } } -type awsAwsquery_deserializeOpDescribeDBClusterParameterGroups struct { +type awsAwsquery_deserializeOpDescribeDBClusterEndpoints struct { } -func (*awsAwsquery_deserializeOpDescribeDBClusterParameterGroups) ID() string { +func (*awsAwsquery_deserializeOpDescribeDBClusterEndpoints) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeDBClusterParameterGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDescribeDBClusterEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6226,9 +6358,9 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterParameterGroups) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterParameterGroups(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterEndpoints(response, &metadata) } - output := &DescribeDBClusterParameterGroupsOutput{} + output := &DescribeDBClusterEndpointsOutput{} out.Result = output var buff [1024]byte @@ -6249,7 +6381,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterParameterGroups) HandleDeseri } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeDBClusterParameterGroupsResult") + t, err = decoder.GetElement("DescribeDBClusterEndpointsResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6261,7 +6393,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterParameterGroups) HandleDeseri } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeDBClusterParameterGroupsOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDescribeDBClusterEndpointsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6275,7 +6407,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterParameterGroups) HandleDeseri return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeDBClusterParameterGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDescribeDBClusterEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6300,8 +6432,8 @@ func awsAwsquery_deserializeOpErrorDescribeDBClusterParameterGroups(response *sm } errorBody.Seek(0, io.SeekStart) switch { - case strings.EqualFold("DBParameterGroupNotFound", errorCode): - return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) + case strings.EqualFold("DBClusterNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -6313,14 +6445,14 @@ func awsAwsquery_deserializeOpErrorDescribeDBClusterParameterGroups(response *sm } } -type awsAwsquery_deserializeOpDescribeDBClusterParameters struct { +type awsAwsquery_deserializeOpDescribeDBClusterParameterGroups struct { } -func (*awsAwsquery_deserializeOpDescribeDBClusterParameters) ID() string { +func (*awsAwsquery_deserializeOpDescribeDBClusterParameterGroups) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeDBClusterParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDescribeDBClusterParameterGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6334,9 +6466,9 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterParameters) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterParameters(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterParameterGroups(response, &metadata) } - output := &DescribeDBClusterParametersOutput{} + output := &DescribeDBClusterParameterGroupsOutput{} out.Result = output var buff [1024]byte @@ -6357,7 +6489,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterParameters) HandleDeserialize } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeDBClusterParametersResult") + t, err = decoder.GetElement("DescribeDBClusterParameterGroupsResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6369,7 +6501,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterParameters) HandleDeserialize } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeDBClusterParametersOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDescribeDBClusterParameterGroupsOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6383,7 +6515,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusterParameters) HandleDeserialize return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeDBClusterParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDescribeDBClusterParameterGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6421,14 +6553,14 @@ func awsAwsquery_deserializeOpErrorDescribeDBClusterParameters(response *smithyh } } -type awsAwsquery_deserializeOpDescribeDBClusters struct { +type awsAwsquery_deserializeOpDescribeDBClusterParameters struct { } -func (*awsAwsquery_deserializeOpDescribeDBClusters) ID() string { +func (*awsAwsquery_deserializeOpDescribeDBClusterParameters) ID() string { return "OperationDeserializer" } -func (m *awsAwsquery_deserializeOpDescribeDBClusters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsquery_deserializeOpDescribeDBClusterParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6442,9 +6574,9 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusters) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusters(response, &metadata) + return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterParameters(response, &metadata) } - output := &DescribeDBClustersOutput{} + output := &DescribeDBClusterParametersOutput{} out.Result = output var buff [1024]byte @@ -6465,7 +6597,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusters) HandleDeserialize(ctx cont } decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("DescribeDBClustersResult") + t, err = decoder.GetElement("DescribeDBClusterParametersResult") if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6477,7 +6609,7 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusters) HandleDeserialize(ctx cont } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeOpDocumentDescribeDBClustersOutput(&output, decoder) + err = awsAwsquery_deserializeOpDocumentDescribeDBClusterParametersOutput(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6491,7 +6623,115 @@ func (m *awsAwsquery_deserializeOpDescribeDBClusters) HandleDeserialize(ctx cont return out, metadata, err } -func awsAwsquery_deserializeOpErrorDescribeDBClusters(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsquery_deserializeOpErrorDescribeDBClusterParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) + if err != nil { + return err + } + if reqID := errorComponents.RequestID; len(reqID) != 0 { + awsmiddleware.SetRequestIDMetadata(metadata, reqID) + } + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + case strings.EqualFold("DBParameterGroupNotFound", errorCode): + return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsquery_deserializeOpDescribeDBClusters struct { +} + +func (*awsAwsquery_deserializeOpDescribeDBClusters) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsquery_deserializeOpDescribeDBClusters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusters(response, &metadata) + } + output := &DescribeDBClustersOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("DescribeDBClustersResult") + if err != nil { + var 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 + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeOpDocumentDescribeDBClustersOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsquery_deserializeOpErrorDescribeDBClusters(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -9016,6 +9256,114 @@ func awsAwsquery_deserializeOpErrorDescribeGlobalClusters(response *smithyhttp.R } } +type awsAwsquery_deserializeOpDescribeIntegrations struct { +} + +func (*awsAwsquery_deserializeOpDescribeIntegrations) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsquery_deserializeOpDescribeIntegrations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsquery_deserializeOpErrorDescribeIntegrations(response, &metadata) + } + output := &DescribeIntegrationsOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("DescribeIntegrationsResult") + if err != nil { + var 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 + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeOpDocumentDescribeIntegrationsOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsAwsquery_deserializeOpErrorDescribeIntegrations(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) + if err != nil { + return err + } + if reqID := errorComponents.RequestID; len(reqID) != 0 { + awsmiddleware.SetRequestIDMetadata(metadata, reqID) + } + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + case strings.EqualFold("IntegrationNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorIntegrationNotFoundFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsAwsquery_deserializeOpDescribeOptionGroupOptions struct { } @@ -10329,6 +10677,9 @@ func awsAwsquery_deserializeOpErrorListTagsForResource(response *smithyhttp.Resp case strings.EqualFold("DBSnapshotNotFound", errorCode): return awsAwsquery_deserializeErrorDBSnapshotNotFoundFault(response, errorBody) + case strings.EqualFold("IntegrationNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorIntegrationNotFoundFault(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -13746,6 +14097,9 @@ func awsAwsquery_deserializeOpErrorRemoveTagsFromResource(response *smithyhttp.R case strings.EqualFold("DBSnapshotNotFound", errorCode): return awsAwsquery_deserializeErrorDBSnapshotNotFoundFault(response, errorBody) + case strings.EqualFold("IntegrationNotFoundFault", errorCode): + return awsAwsquery_deserializeErrorIntegrationNotFoundFault(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -19804,8 +20158,8 @@ func awsAwsquery_deserializeErrorInsufficientStorageClusterCapacityFault(respons return output } -func awsAwsquery_deserializeErrorInvalidBlueGreenDeploymentStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidBlueGreenDeploymentStateFault{} +func awsAwsquery_deserializeErrorIntegrationAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.IntegrationAlreadyExistsFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -19835,7 +20189,7 @@ func awsAwsquery_deserializeErrorInvalidBlueGreenDeploymentStateFault(response * } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidBlueGreenDeploymentStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentIntegrationAlreadyExistsFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -19848,8 +20202,8 @@ func awsAwsquery_deserializeErrorInvalidBlueGreenDeploymentStateFault(response * return output } -func awsAwsquery_deserializeErrorInvalidCustomDBEngineVersionStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidCustomDBEngineVersionStateFault{} +func awsAwsquery_deserializeErrorIntegrationConflictOperationFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.IntegrationConflictOperationFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -19879,7 +20233,7 @@ func awsAwsquery_deserializeErrorInvalidCustomDBEngineVersionStateFault(response } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidCustomDBEngineVersionStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentIntegrationConflictOperationFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -19892,8 +20246,8 @@ func awsAwsquery_deserializeErrorInvalidCustomDBEngineVersionStateFault(response return output } -func awsAwsquery_deserializeErrorInvalidDBClusterAutomatedBackupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBClusterAutomatedBackupStateFault{} +func awsAwsquery_deserializeErrorIntegrationNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.IntegrationNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -19923,7 +20277,7 @@ func awsAwsquery_deserializeErrorInvalidDBClusterAutomatedBackupStateFault(respo } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBClusterAutomatedBackupStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentIntegrationNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -19936,8 +20290,8 @@ func awsAwsquery_deserializeErrorInvalidDBClusterAutomatedBackupStateFault(respo return output } -func awsAwsquery_deserializeErrorInvalidDBClusterCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBClusterCapacityFault{} +func awsAwsquery_deserializeErrorIntegrationQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.IntegrationQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -19967,7 +20321,7 @@ func awsAwsquery_deserializeErrorInvalidDBClusterCapacityFault(response *smithyh } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBClusterCapacityFault(&output, decoder) + err = awsAwsquery_deserializeDocumentIntegrationQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -19980,8 +20334,8 @@ func awsAwsquery_deserializeErrorInvalidDBClusterCapacityFault(response *smithyh return output } -func awsAwsquery_deserializeErrorInvalidDBClusterEndpointStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBClusterEndpointStateFault{} +func awsAwsquery_deserializeErrorInvalidBlueGreenDeploymentStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidBlueGreenDeploymentStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20011,7 +20365,7 @@ func awsAwsquery_deserializeErrorInvalidDBClusterEndpointStateFault(response *sm } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBClusterEndpointStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidBlueGreenDeploymentStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20024,8 +20378,8 @@ func awsAwsquery_deserializeErrorInvalidDBClusterEndpointStateFault(response *sm return output } -func awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBClusterSnapshotStateFault{} +func awsAwsquery_deserializeErrorInvalidCustomDBEngineVersionStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidCustomDBEngineVersionStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20055,7 +20409,7 @@ func awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response *sm } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBClusterSnapshotStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidCustomDBEngineVersionStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20068,8 +20422,8 @@ func awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response *sm return output } -func awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBClusterStateFault{} +func awsAwsquery_deserializeErrorInvalidDBClusterAutomatedBackupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBClusterAutomatedBackupStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20099,7 +20453,7 @@ func awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response *smithyhttp } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBClusterStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBClusterAutomatedBackupStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20112,8 +20466,8 @@ func awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response *smithyhttp return output } -func awsAwsquery_deserializeErrorInvalidDBInstanceAutomatedBackupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBInstanceAutomatedBackupStateFault{} +func awsAwsquery_deserializeErrorInvalidDBClusterCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBClusterCapacityFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20143,7 +20497,7 @@ func awsAwsquery_deserializeErrorInvalidDBInstanceAutomatedBackupStateFault(resp } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBInstanceAutomatedBackupStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBClusterCapacityFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20156,8 +20510,8 @@ func awsAwsquery_deserializeErrorInvalidDBInstanceAutomatedBackupStateFault(resp return output } -func awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBInstanceStateFault{} +func awsAwsquery_deserializeErrorInvalidDBClusterEndpointStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBClusterEndpointStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20187,7 +20541,7 @@ func awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response *smithyhtt } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBInstanceStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBClusterEndpointStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20200,8 +20554,8 @@ func awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response *smithyhtt return output } -func awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBParameterGroupStateFault{} +func awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBClusterSnapshotStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20231,7 +20585,7 @@ func awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response *smi } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBParameterGroupStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBClusterSnapshotStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20244,8 +20598,8 @@ func awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response *smi return output } -func awsAwsquery_deserializeErrorInvalidDBProxyEndpointStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBProxyEndpointStateFault{} +func awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBClusterStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20275,183 +20629,7 @@ func awsAwsquery_deserializeErrorInvalidDBProxyEndpointStateFault(response *smit } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBProxyEndpointStateFault(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - return output -} - -func awsAwsquery_deserializeErrorInvalidDBProxyStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBProxyStateFault{} - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return output - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("Error") - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBProxyStateFault(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - return output -} - -func awsAwsquery_deserializeErrorInvalidDBSecurityGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBSecurityGroupStateFault{} - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return output - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("Error") - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBSecurityGroupStateFault(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - return output -} - -func awsAwsquery_deserializeErrorInvalidDBSnapshotStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBSnapshotStateFault{} - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return output - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("Error") - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBSnapshotStateFault(&output, decoder) - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - return output -} - -func awsAwsquery_deserializeErrorInvalidDBSubnetGroupFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBSubnetGroupFault{} - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) - rootDecoder := xml.NewDecoder(body) - t, err := smithyxml.FetchRootElement(rootDecoder) - if err == io.EOF { - return output - } - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) - t, err = decoder.GetElement("Error") - if err != nil { - var snapshot bytes.Buffer - io.Copy(&snapshot, ringBuffer) - return &smithy.DeserializationError{ - Err: fmt.Errorf("failed to decode response body, %w", err), - Snapshot: snapshot.Bytes(), - } - } - - decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBSubnetGroupFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBClusterStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20464,8 +20642,8 @@ func awsAwsquery_deserializeErrorInvalidDBSubnetGroupFault(response *smithyhttp. return output } -func awsAwsquery_deserializeErrorInvalidDBSubnetGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBSubnetGroupStateFault{} +func awsAwsquery_deserializeErrorInvalidDBInstanceAutomatedBackupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBInstanceAutomatedBackupStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20495,7 +20673,7 @@ func awsAwsquery_deserializeErrorInvalidDBSubnetGroupStateFault(response *smithy } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBSubnetGroupStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBInstanceAutomatedBackupStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20508,8 +20686,8 @@ func awsAwsquery_deserializeErrorInvalidDBSubnetGroupStateFault(response *smithy return output } -func awsAwsquery_deserializeErrorInvalidDBSubnetStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidDBSubnetStateFault{} +func awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBInstanceStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20539,7 +20717,7 @@ func awsAwsquery_deserializeErrorInvalidDBSubnetStateFault(response *smithyhttp. } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidDBSubnetStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBInstanceStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20552,8 +20730,8 @@ func awsAwsquery_deserializeErrorInvalidDBSubnetStateFault(response *smithyhttp. return output } -func awsAwsquery_deserializeErrorInvalidEventSubscriptionStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidEventSubscriptionStateFault{} +func awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBParameterGroupStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20583,7 +20761,7 @@ func awsAwsquery_deserializeErrorInvalidEventSubscriptionStateFault(response *sm } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidEventSubscriptionStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBParameterGroupStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20596,8 +20774,8 @@ func awsAwsquery_deserializeErrorInvalidEventSubscriptionStateFault(response *sm return output } -func awsAwsquery_deserializeErrorInvalidExportOnlyFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidExportOnlyFault{} +func awsAwsquery_deserializeErrorInvalidDBProxyEndpointStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBProxyEndpointStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20627,7 +20805,7 @@ func awsAwsquery_deserializeErrorInvalidExportOnlyFault(response *smithyhttp.Res } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidExportOnlyFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBProxyEndpointStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20640,8 +20818,8 @@ func awsAwsquery_deserializeErrorInvalidExportOnlyFault(response *smithyhttp.Res return output } -func awsAwsquery_deserializeErrorInvalidExportSourceStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidExportSourceStateFault{} +func awsAwsquery_deserializeErrorInvalidDBProxyStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBProxyStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20671,7 +20849,7 @@ func awsAwsquery_deserializeErrorInvalidExportSourceStateFault(response *smithyh } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidExportSourceStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBProxyStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20684,8 +20862,8 @@ func awsAwsquery_deserializeErrorInvalidExportSourceStateFault(response *smithyh return output } -func awsAwsquery_deserializeErrorInvalidExportTaskStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidExportTaskStateFault{} +func awsAwsquery_deserializeErrorInvalidDBSecurityGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBSecurityGroupStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20715,7 +20893,7 @@ func awsAwsquery_deserializeErrorInvalidExportTaskStateFault(response *smithyhtt } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidExportTaskStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBSecurityGroupStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20728,8 +20906,8 @@ func awsAwsquery_deserializeErrorInvalidExportTaskStateFault(response *smithyhtt return output } -func awsAwsquery_deserializeErrorInvalidGlobalClusterStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidGlobalClusterStateFault{} +func awsAwsquery_deserializeErrorInvalidDBSnapshotStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBSnapshotStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20759,7 +20937,7 @@ func awsAwsquery_deserializeErrorInvalidGlobalClusterStateFault(response *smithy } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidGlobalClusterStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBSnapshotStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20772,8 +20950,8 @@ func awsAwsquery_deserializeErrorInvalidGlobalClusterStateFault(response *smithy return output } -func awsAwsquery_deserializeErrorInvalidOptionGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidOptionGroupStateFault{} +func awsAwsquery_deserializeErrorInvalidDBSubnetGroupFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBSubnetGroupFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20803,7 +20981,7 @@ func awsAwsquery_deserializeErrorInvalidOptionGroupStateFault(response *smithyht } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidOptionGroupStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBSubnetGroupFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20816,8 +20994,8 @@ func awsAwsquery_deserializeErrorInvalidOptionGroupStateFault(response *smithyht return output } -func awsAwsquery_deserializeErrorInvalidRestoreFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidRestoreFault{} +func awsAwsquery_deserializeErrorInvalidDBSubnetGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBSubnetGroupStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20847,7 +21025,7 @@ func awsAwsquery_deserializeErrorInvalidRestoreFault(response *smithyhttp.Respon } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidRestoreFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBSubnetGroupStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20860,8 +21038,8 @@ func awsAwsquery_deserializeErrorInvalidRestoreFault(response *smithyhttp.Respon return output } -func awsAwsquery_deserializeErrorInvalidS3BucketFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidS3BucketFault{} +func awsAwsquery_deserializeErrorInvalidDBSubnetStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidDBSubnetStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20891,7 +21069,7 @@ func awsAwsquery_deserializeErrorInvalidS3BucketFault(response *smithyhttp.Respo } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidS3BucketFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidDBSubnetStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20904,8 +21082,8 @@ func awsAwsquery_deserializeErrorInvalidS3BucketFault(response *smithyhttp.Respo return output } -func awsAwsquery_deserializeErrorInvalidSubnet(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidSubnet{} +func awsAwsquery_deserializeErrorInvalidEventSubscriptionStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidEventSubscriptionStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20935,7 +21113,7 @@ func awsAwsquery_deserializeErrorInvalidSubnet(response *smithyhttp.Response, er } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidSubnet(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidEventSubscriptionStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20948,8 +21126,8 @@ func awsAwsquery_deserializeErrorInvalidSubnet(response *smithyhttp.Response, er return output } -func awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.InvalidVPCNetworkStateFault{} +func awsAwsquery_deserializeErrorInvalidExportOnlyFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidExportOnlyFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -20979,7 +21157,7 @@ func awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response *smithyhtt } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentInvalidVPCNetworkStateFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidExportOnlyFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -20992,8 +21170,8 @@ func awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response *smithyhtt return output } -func awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.KMSKeyNotAccessibleFault{} +func awsAwsquery_deserializeErrorInvalidExportSourceStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidExportSourceStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21023,7 +21201,7 @@ func awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response *smithyhttp.R } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentKMSKeyNotAccessibleFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidExportSourceStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21036,8 +21214,8 @@ func awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response *smithyhttp.R return output } -func awsAwsquery_deserializeErrorNetworkTypeNotSupported(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.NetworkTypeNotSupported{} +func awsAwsquery_deserializeErrorInvalidExportTaskStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidExportTaskStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21067,7 +21245,7 @@ func awsAwsquery_deserializeErrorNetworkTypeNotSupported(response *smithyhttp.Re } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentNetworkTypeNotSupported(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidExportTaskStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21080,8 +21258,8 @@ func awsAwsquery_deserializeErrorNetworkTypeNotSupported(response *smithyhttp.Re return output } -func awsAwsquery_deserializeErrorOptionGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.OptionGroupAlreadyExistsFault{} +func awsAwsquery_deserializeErrorInvalidGlobalClusterStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidGlobalClusterStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21111,7 +21289,7 @@ func awsAwsquery_deserializeErrorOptionGroupAlreadyExistsFault(response *smithyh } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentOptionGroupAlreadyExistsFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidGlobalClusterStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21124,8 +21302,8 @@ func awsAwsquery_deserializeErrorOptionGroupAlreadyExistsFault(response *smithyh return output } -func awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.OptionGroupNotFoundFault{} +func awsAwsquery_deserializeErrorInvalidIntegrationStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidIntegrationStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21155,7 +21333,7 @@ func awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response *smithyhttp.R } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentOptionGroupNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidIntegrationStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21168,8 +21346,8 @@ func awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response *smithyhttp.R return output } -func awsAwsquery_deserializeErrorOptionGroupQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.OptionGroupQuotaExceededFault{} +func awsAwsquery_deserializeErrorInvalidOptionGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidOptionGroupStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21199,7 +21377,7 @@ func awsAwsquery_deserializeErrorOptionGroupQuotaExceededFault(response *smithyh } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentOptionGroupQuotaExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidOptionGroupStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21212,8 +21390,8 @@ func awsAwsquery_deserializeErrorOptionGroupQuotaExceededFault(response *smithyh return output } -func awsAwsquery_deserializeErrorPointInTimeRestoreNotEnabledFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.PointInTimeRestoreNotEnabledFault{} +func awsAwsquery_deserializeErrorInvalidRestoreFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidRestoreFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21243,7 +21421,7 @@ func awsAwsquery_deserializeErrorPointInTimeRestoreNotEnabledFault(response *smi } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentPointInTimeRestoreNotEnabledFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidRestoreFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21256,8 +21434,8 @@ func awsAwsquery_deserializeErrorPointInTimeRestoreNotEnabledFault(response *smi return output } -func awsAwsquery_deserializeErrorProvisionedIopsNotAvailableInAZFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ProvisionedIopsNotAvailableInAZFault{} +func awsAwsquery_deserializeErrorInvalidS3BucketFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidS3BucketFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21287,7 +21465,7 @@ func awsAwsquery_deserializeErrorProvisionedIopsNotAvailableInAZFault(response * } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentProvisionedIopsNotAvailableInAZFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidS3BucketFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21300,8 +21478,8 @@ func awsAwsquery_deserializeErrorProvisionedIopsNotAvailableInAZFault(response * return output } -func awsAwsquery_deserializeErrorReservedDBInstanceAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ReservedDBInstanceAlreadyExistsFault{} +func awsAwsquery_deserializeErrorInvalidSubnet(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidSubnet{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21331,7 +21509,7 @@ func awsAwsquery_deserializeErrorReservedDBInstanceAlreadyExistsFault(response * } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentReservedDBInstanceAlreadyExistsFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidSubnet(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21344,8 +21522,8 @@ func awsAwsquery_deserializeErrorReservedDBInstanceAlreadyExistsFault(response * return output } -func awsAwsquery_deserializeErrorReservedDBInstanceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ReservedDBInstanceNotFoundFault{} +func awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.InvalidVPCNetworkStateFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21375,7 +21553,7 @@ func awsAwsquery_deserializeErrorReservedDBInstanceNotFoundFault(response *smith } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentReservedDBInstanceNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentInvalidVPCNetworkStateFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21388,8 +21566,8 @@ func awsAwsquery_deserializeErrorReservedDBInstanceNotFoundFault(response *smith return output } -func awsAwsquery_deserializeErrorReservedDBInstanceQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ReservedDBInstanceQuotaExceededFault{} +func awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.KMSKeyNotAccessibleFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21419,7 +21597,7 @@ func awsAwsquery_deserializeErrorReservedDBInstanceQuotaExceededFault(response * } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentReservedDBInstanceQuotaExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentKMSKeyNotAccessibleFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21432,8 +21610,8 @@ func awsAwsquery_deserializeErrorReservedDBInstanceQuotaExceededFault(response * return output } -func awsAwsquery_deserializeErrorReservedDBInstancesOfferingNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ReservedDBInstancesOfferingNotFoundFault{} +func awsAwsquery_deserializeErrorNetworkTypeNotSupported(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.NetworkTypeNotSupported{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21463,7 +21641,7 @@ func awsAwsquery_deserializeErrorReservedDBInstancesOfferingNotFoundFault(respon } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentReservedDBInstancesOfferingNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentNetworkTypeNotSupported(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21476,8 +21654,8 @@ func awsAwsquery_deserializeErrorReservedDBInstancesOfferingNotFoundFault(respon return output } -func awsAwsquery_deserializeErrorResourceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.ResourceNotFoundFault{} +func awsAwsquery_deserializeErrorOptionGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.OptionGroupAlreadyExistsFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21507,7 +21685,7 @@ func awsAwsquery_deserializeErrorResourceNotFoundFault(response *smithyhttp.Resp } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentResourceNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentOptionGroupAlreadyExistsFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21520,8 +21698,8 @@ func awsAwsquery_deserializeErrorResourceNotFoundFault(response *smithyhttp.Resp return output } -func awsAwsquery_deserializeErrorSharedSnapshotQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SharedSnapshotQuotaExceededFault{} +func awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.OptionGroupNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21551,7 +21729,7 @@ func awsAwsquery_deserializeErrorSharedSnapshotQuotaExceededFault(response *smit } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSharedSnapshotQuotaExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentOptionGroupNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21564,8 +21742,8 @@ func awsAwsquery_deserializeErrorSharedSnapshotQuotaExceededFault(response *smit return output } -func awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SnapshotQuotaExceededFault{} +func awsAwsquery_deserializeErrorOptionGroupQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.OptionGroupQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21595,7 +21773,7 @@ func awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response *smithyhttp } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSnapshotQuotaExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentOptionGroupQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21608,8 +21786,8 @@ func awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response *smithyhttp return output } -func awsAwsquery_deserializeErrorSNSInvalidTopicFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SNSInvalidTopicFault{} +func awsAwsquery_deserializeErrorPointInTimeRestoreNotEnabledFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.PointInTimeRestoreNotEnabledFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21639,7 +21817,7 @@ func awsAwsquery_deserializeErrorSNSInvalidTopicFault(response *smithyhttp.Respo } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSNSInvalidTopicFault(&output, decoder) + err = awsAwsquery_deserializeDocumentPointInTimeRestoreNotEnabledFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21652,8 +21830,8 @@ func awsAwsquery_deserializeErrorSNSInvalidTopicFault(response *smithyhttp.Respo return output } -func awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SNSNoAuthorizationFault{} +func awsAwsquery_deserializeErrorProvisionedIopsNotAvailableInAZFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ProvisionedIopsNotAvailableInAZFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21683,7 +21861,7 @@ func awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response *smithyhttp.Re } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSNSNoAuthorizationFault(&output, decoder) + err = awsAwsquery_deserializeDocumentProvisionedIopsNotAvailableInAZFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21696,8 +21874,8 @@ func awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response *smithyhttp.Re return output } -func awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SNSTopicArnNotFoundFault{} +func awsAwsquery_deserializeErrorReservedDBInstanceAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ReservedDBInstanceAlreadyExistsFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21727,7 +21905,7 @@ func awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response *smithyhttp.R } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSNSTopicArnNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentReservedDBInstanceAlreadyExistsFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21740,8 +21918,8 @@ func awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response *smithyhttp.R return output } -func awsAwsquery_deserializeErrorSourceClusterNotSupportedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SourceClusterNotSupportedFault{} +func awsAwsquery_deserializeErrorReservedDBInstanceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ReservedDBInstanceNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21771,7 +21949,7 @@ func awsAwsquery_deserializeErrorSourceClusterNotSupportedFault(response *smithy } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSourceClusterNotSupportedFault(&output, decoder) + err = awsAwsquery_deserializeDocumentReservedDBInstanceNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21784,8 +21962,8 @@ func awsAwsquery_deserializeErrorSourceClusterNotSupportedFault(response *smithy return output } -func awsAwsquery_deserializeErrorSourceDatabaseNotSupportedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SourceDatabaseNotSupportedFault{} +func awsAwsquery_deserializeErrorReservedDBInstanceQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ReservedDBInstanceQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21815,7 +21993,7 @@ func awsAwsquery_deserializeErrorSourceDatabaseNotSupportedFault(response *smith } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSourceDatabaseNotSupportedFault(&output, decoder) + err = awsAwsquery_deserializeDocumentReservedDBInstanceQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21828,8 +22006,8 @@ func awsAwsquery_deserializeErrorSourceDatabaseNotSupportedFault(response *smith return output } -func awsAwsquery_deserializeErrorSourceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SourceNotFoundFault{} +func awsAwsquery_deserializeErrorReservedDBInstancesOfferingNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ReservedDBInstancesOfferingNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21859,7 +22037,7 @@ func awsAwsquery_deserializeErrorSourceNotFoundFault(response *smithyhttp.Respon } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSourceNotFoundFault(&output, decoder) + err = awsAwsquery_deserializeDocumentReservedDBInstancesOfferingNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21872,8 +22050,8 @@ func awsAwsquery_deserializeErrorSourceNotFoundFault(response *smithyhttp.Respon return output } -func awsAwsquery_deserializeErrorStorageQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.StorageQuotaExceededFault{} +func awsAwsquery_deserializeErrorResourceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.ResourceNotFoundFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21903,7 +22081,7 @@ func awsAwsquery_deserializeErrorStorageQuotaExceededFault(response *smithyhttp. } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentStorageQuotaExceededFault(&output, decoder) + err = awsAwsquery_deserializeDocumentResourceNotFoundFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21916,8 +22094,8 @@ func awsAwsquery_deserializeErrorStorageQuotaExceededFault(response *smithyhttp. return output } -func awsAwsquery_deserializeErrorStorageTypeNotAvailableFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.StorageTypeNotAvailableFault{} +func awsAwsquery_deserializeErrorSharedSnapshotQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SharedSnapshotQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21947,7 +22125,7 @@ func awsAwsquery_deserializeErrorStorageTypeNotAvailableFault(response *smithyht } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentStorageTypeNotAvailableFault(&output, decoder) + err = awsAwsquery_deserializeDocumentSharedSnapshotQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -21960,8 +22138,8 @@ func awsAwsquery_deserializeErrorStorageTypeNotAvailableFault(response *smithyht return output } -func awsAwsquery_deserializeErrorStorageTypeNotSupportedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.StorageTypeNotSupportedFault{} +func awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SnapshotQuotaExceededFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -21991,7 +22169,7 @@ func awsAwsquery_deserializeErrorStorageTypeNotSupportedFault(response *smithyht } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentStorageTypeNotSupportedFault(&output, decoder) + err = awsAwsquery_deserializeDocumentSnapshotQuotaExceededFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -22004,8 +22182,8 @@ func awsAwsquery_deserializeErrorStorageTypeNotSupportedFault(response *smithyht return output } -func awsAwsquery_deserializeErrorSubnetAlreadyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SubnetAlreadyInUse{} +func awsAwsquery_deserializeErrorSNSInvalidTopicFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SNSInvalidTopicFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -22035,7 +22213,7 @@ func awsAwsquery_deserializeErrorSubnetAlreadyInUse(response *smithyhttp.Respons } decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) - err = awsAwsquery_deserializeDocumentSubnetAlreadyInUse(&output, decoder) + err = awsAwsquery_deserializeDocumentSNSInvalidTopicFault(&output, decoder) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -22048,8 +22226,404 @@ func awsAwsquery_deserializeErrorSubnetAlreadyInUse(response *smithyhttp.Respons return output } -func awsAwsquery_deserializeErrorSubscriptionAlreadyExistFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - output := &types.SubscriptionAlreadyExistFault{} +func awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SNSNoAuthorizationFault{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentSNSNoAuthorizationFault(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SNSTopicArnNotFoundFault{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentSNSTopicArnNotFoundFault(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorSourceClusterNotSupportedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SourceClusterNotSupportedFault{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentSourceClusterNotSupportedFault(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorSourceDatabaseNotSupportedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SourceDatabaseNotSupportedFault{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentSourceDatabaseNotSupportedFault(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorSourceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SourceNotFoundFault{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentSourceNotFoundFault(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorStorageQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.StorageQuotaExceededFault{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentStorageQuotaExceededFault(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorStorageTypeNotAvailableFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.StorageTypeNotAvailableFault{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentStorageTypeNotAvailableFault(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorStorageTypeNotSupportedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.StorageTypeNotSupportedFault{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentStorageTypeNotSupportedFault(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorSubnetAlreadyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SubnetAlreadyInUse{} + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(errorBody, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return output + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + t, err = decoder.GetElement("Error") + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) + err = awsAwsquery_deserializeDocumentSubnetAlreadyInUse(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return output +} + +func awsAwsquery_deserializeErrorSubscriptionAlreadyExistFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + output := &types.SubscriptionAlreadyExistFault{} var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) @@ -28702,6 +29276,22 @@ func awsAwsquery_deserializeDocumentDBEngineVersion(v **types.DBEngineVersion, d sv.SupportsGlobalDatabases = ptr.Bool(xtv) } + case strings.EqualFold("SupportsIntegrations", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv, err := strconv.ParseBool(string(val)) + if err != nil { + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) + } + sv.SupportsIntegrations = ptr.Bool(xtv) + } + case strings.EqualFold("SupportsLocalWriteForwarding", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -35654,6 +36244,104 @@ func awsAwsquery_deserializeDocumentEC2SecurityGroupListUnwrapped(v *[]types.EC2 *v = sv return nil } +func awsAwsquery_deserializeDocumentEncryptionContextMap(v *map[string]string, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv map[string]string + if *v == nil { + sv = make(map[string]string, 0) + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + switch { + case strings.EqualFold("entry", t.Name.Local): + entryDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentEncryptionContextMapUnwrapped(&sv, entryDecoder); err != nil { + return err + } + + default: + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentEncryptionContextMapUnwrapped(v *map[string]string, decoder smithyxml.NodeDecoder) error { + var sv map[string]string + if *v == nil { + sv = make(map[string]string, 0) + } else { + sv = *v + } + + var ek string + var ev string + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + sv[ek] = ev + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("key", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + ek = xtv + } + + case strings.EqualFold("value", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + ev = xtv + } + + default: + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} func awsAwsquery_deserializeDocumentEndpoint(v **types.Endpoint, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -38023,13 +38711,13 @@ func awsAwsquery_deserializeDocumentInsufficientStorageClusterCapacityFault(v ** return nil } -func awsAwsquery_deserializeDocumentInvalidBlueGreenDeploymentStateFault(v **types.InvalidBlueGreenDeploymentStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentIntegration(v **types.Integration, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidBlueGreenDeploymentStateFault + var sv *types.Integration if *v == nil { - sv = &types.InvalidBlueGreenDeploymentStateFault{} + sv = &types.Integration{} } else { sv = *v } @@ -38045,7 +38733,13 @@ func awsAwsquery_deserializeDocumentInvalidBlueGreenDeploymentStateFault(v **typ originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("message", t.Name.Local): + case strings.EqualFold("AdditionalEncryptionContext", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentEncryptionContextMap(&sv.AdditionalEncryptionContext, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("CreateTime", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -38055,7 +38749,101 @@ func awsAwsquery_deserializeDocumentInvalidBlueGreenDeploymentStateFault(v **typ } { xtv := string(val) - sv.Message = ptr.String(xtv) + t, err := smithytime.ParseDateTime(xtv) + if err != nil { + return err + } + sv.CreateTime = ptr.Time(t) + } + + case strings.EqualFold("Errors", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentIntegrationErrorList(&sv.Errors, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("IntegrationArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IntegrationArn = ptr.String(xtv) + } + + case strings.EqualFold("IntegrationName", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IntegrationName = ptr.String(xtv) + } + + case strings.EqualFold("KMSKeyId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.KMSKeyId = ptr.String(xtv) + } + + case strings.EqualFold("SourceArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SourceArn = ptr.String(xtv) + } + + case strings.EqualFold("Status", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Status = types.IntegrationStatus(xtv) + } + + case strings.EqualFold("Tags", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("TargetArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.TargetArn = ptr.String(xtv) } default: @@ -38072,13 +38860,13 @@ func awsAwsquery_deserializeDocumentInvalidBlueGreenDeploymentStateFault(v **typ return nil } -func awsAwsquery_deserializeDocumentInvalidCustomDBEngineVersionStateFault(v **types.InvalidCustomDBEngineVersionStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentIntegrationAlreadyExistsFault(v **types.IntegrationAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidCustomDBEngineVersionStateFault + var sv *types.IntegrationAlreadyExistsFault if *v == nil { - sv = &types.InvalidCustomDBEngineVersionStateFault{} + sv = &types.IntegrationAlreadyExistsFault{} } else { sv = *v } @@ -38121,13 +38909,13 @@ func awsAwsquery_deserializeDocumentInvalidCustomDBEngineVersionStateFault(v **t return nil } -func awsAwsquery_deserializeDocumentInvalidDBClusterAutomatedBackupStateFault(v **types.InvalidDBClusterAutomatedBackupStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentIntegrationConflictOperationFault(v **types.IntegrationConflictOperationFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBClusterAutomatedBackupStateFault + var sv *types.IntegrationConflictOperationFault if *v == nil { - sv = &types.InvalidDBClusterAutomatedBackupStateFault{} + sv = &types.IntegrationConflictOperationFault{} } else { sv = *v } @@ -38170,13 +38958,13 @@ func awsAwsquery_deserializeDocumentInvalidDBClusterAutomatedBackupStateFault(v return nil } -func awsAwsquery_deserializeDocumentInvalidDBClusterCapacityFault(v **types.InvalidDBClusterCapacityFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentIntegrationError(v **types.IntegrationError, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBClusterCapacityFault + var sv *types.IntegrationError if *v == nil { - sv = &types.InvalidDBClusterCapacityFault{} + sv = &types.IntegrationError{} } else { sv = *v } @@ -38192,7 +38980,7 @@ func awsAwsquery_deserializeDocumentInvalidDBClusterCapacityFault(v **types.Inva originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("message", t.Name.Local): + case strings.EqualFold("ErrorCode", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -38202,7 +38990,20 @@ func awsAwsquery_deserializeDocumentInvalidDBClusterCapacityFault(v **types.Inva } { xtv := string(val) - sv.Message = ptr.String(xtv) + sv.ErrorCode = ptr.String(xtv) + } + + case strings.EqualFold("ErrorMessage", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.ErrorMessage = ptr.String(xtv) } default: @@ -38219,17 +39020,18 @@ func awsAwsquery_deserializeDocumentInvalidDBClusterCapacityFault(v **types.Inva return nil } -func awsAwsquery_deserializeDocumentInvalidDBClusterEndpointStateFault(v **types.InvalidDBClusterEndpointStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentIntegrationErrorList(v *[]types.IntegrationError, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBClusterEndpointStateFault + var sv []types.IntegrationError if *v == nil { - sv = &types.InvalidDBClusterEndpointStateFault{} + sv = make([]types.IntegrationError, 0) } else { sv = *v } + originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { @@ -38238,24 +39040,18 @@ func awsAwsquery_deserializeDocumentInvalidDBClusterEndpointStateFault(v **types if done { break } - originalDecoder := decoder - decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("message", t.Name.Local): - val, err := decoder.Value() - if err != nil { + case strings.EqualFold("IntegrationError", t.Name.Local): + var col types.IntegrationError + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsAwsquery_deserializeDocumentIntegrationError(&destAddr, nodeDecoder); err != nil { return err } - if val == nil { - break - } - { - xtv := string(val) - sv.Message = ptr.String(xtv) - } + col = *destAddr + sv = append(sv, col) default: - // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err @@ -38268,17 +39064,42 @@ func awsAwsquery_deserializeDocumentInvalidDBClusterEndpointStateFault(v **types return nil } -func awsAwsquery_deserializeDocumentInvalidDBClusterSnapshotStateFault(v **types.InvalidDBClusterSnapshotStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentIntegrationErrorListUnwrapped(v *[]types.IntegrationError, decoder smithyxml.NodeDecoder) error { + var sv []types.IntegrationError + if *v == nil { + sv = make([]types.IntegrationError, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.IntegrationError + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsAwsquery_deserializeDocumentIntegrationError(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsAwsquery_deserializeDocumentIntegrationList(v *[]types.Integration, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBClusterSnapshotStateFault + var sv []types.Integration if *v == nil { - sv = &types.InvalidDBClusterSnapshotStateFault{} + sv = make([]types.Integration, 0) } else { sv = *v } + originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { @@ -38287,24 +39108,18 @@ func awsAwsquery_deserializeDocumentInvalidDBClusterSnapshotStateFault(v **types if done { break } - originalDecoder := decoder - decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("message", t.Name.Local): - val, err := decoder.Value() - if err != nil { + case strings.EqualFold("Integration", t.Name.Local): + var col types.Integration + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsAwsquery_deserializeDocumentIntegration(&destAddr, nodeDecoder); err != nil { return err } - if val == nil { - break - } - { - xtv := string(val) - sv.Message = ptr.String(xtv) - } + col = *destAddr + sv = append(sv, col) default: - // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err @@ -38317,13 +39132,37 @@ func awsAwsquery_deserializeDocumentInvalidDBClusterSnapshotStateFault(v **types return nil } -func awsAwsquery_deserializeDocumentInvalidDBClusterStateFault(v **types.InvalidDBClusterStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentIntegrationListUnwrapped(v *[]types.Integration, decoder smithyxml.NodeDecoder) error { + var sv []types.Integration + if *v == nil { + sv = make([]types.Integration, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.Integration + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsAwsquery_deserializeDocumentIntegration(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsAwsquery_deserializeDocumentIntegrationNotFoundFault(v **types.IntegrationNotFoundFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBClusterStateFault + var sv *types.IntegrationNotFoundFault if *v == nil { - sv = &types.InvalidDBClusterStateFault{} + sv = &types.IntegrationNotFoundFault{} } else { sv = *v } @@ -38366,13 +39205,13 @@ func awsAwsquery_deserializeDocumentInvalidDBClusterStateFault(v **types.Invalid return nil } -func awsAwsquery_deserializeDocumentInvalidDBInstanceAutomatedBackupStateFault(v **types.InvalidDBInstanceAutomatedBackupStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentIntegrationQuotaExceededFault(v **types.IntegrationQuotaExceededFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBInstanceAutomatedBackupStateFault + var sv *types.IntegrationQuotaExceededFault if *v == nil { - sv = &types.InvalidDBInstanceAutomatedBackupStateFault{} + sv = &types.IntegrationQuotaExceededFault{} } else { sv = *v } @@ -38415,13 +39254,13 @@ func awsAwsquery_deserializeDocumentInvalidDBInstanceAutomatedBackupStateFault(v return nil } -func awsAwsquery_deserializeDocumentInvalidDBInstanceStateFault(v **types.InvalidDBInstanceStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidBlueGreenDeploymentStateFault(v **types.InvalidBlueGreenDeploymentStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBInstanceStateFault + var sv *types.InvalidBlueGreenDeploymentStateFault if *v == nil { - sv = &types.InvalidDBInstanceStateFault{} + sv = &types.InvalidBlueGreenDeploymentStateFault{} } else { sv = *v } @@ -38464,13 +39303,13 @@ func awsAwsquery_deserializeDocumentInvalidDBInstanceStateFault(v **types.Invali return nil } -func awsAwsquery_deserializeDocumentInvalidDBParameterGroupStateFault(v **types.InvalidDBParameterGroupStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidCustomDBEngineVersionStateFault(v **types.InvalidCustomDBEngineVersionStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBParameterGroupStateFault + var sv *types.InvalidCustomDBEngineVersionStateFault if *v == nil { - sv = &types.InvalidDBParameterGroupStateFault{} + sv = &types.InvalidCustomDBEngineVersionStateFault{} } else { sv = *v } @@ -38513,13 +39352,13 @@ func awsAwsquery_deserializeDocumentInvalidDBParameterGroupStateFault(v **types. return nil } -func awsAwsquery_deserializeDocumentInvalidDBProxyEndpointStateFault(v **types.InvalidDBProxyEndpointStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBClusterAutomatedBackupStateFault(v **types.InvalidDBClusterAutomatedBackupStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBProxyEndpointStateFault + var sv *types.InvalidDBClusterAutomatedBackupStateFault if *v == nil { - sv = &types.InvalidDBProxyEndpointStateFault{} + sv = &types.InvalidDBClusterAutomatedBackupStateFault{} } else { sv = *v } @@ -38562,13 +39401,13 @@ func awsAwsquery_deserializeDocumentInvalidDBProxyEndpointStateFault(v **types.I return nil } -func awsAwsquery_deserializeDocumentInvalidDBProxyStateFault(v **types.InvalidDBProxyStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBClusterCapacityFault(v **types.InvalidDBClusterCapacityFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBProxyStateFault + var sv *types.InvalidDBClusterCapacityFault if *v == nil { - sv = &types.InvalidDBProxyStateFault{} + sv = &types.InvalidDBClusterCapacityFault{} } else { sv = *v } @@ -38611,13 +39450,13 @@ func awsAwsquery_deserializeDocumentInvalidDBProxyStateFault(v **types.InvalidDB return nil } -func awsAwsquery_deserializeDocumentInvalidDBSecurityGroupStateFault(v **types.InvalidDBSecurityGroupStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBClusterEndpointStateFault(v **types.InvalidDBClusterEndpointStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBSecurityGroupStateFault + var sv *types.InvalidDBClusterEndpointStateFault if *v == nil { - sv = &types.InvalidDBSecurityGroupStateFault{} + sv = &types.InvalidDBClusterEndpointStateFault{} } else { sv = *v } @@ -38660,13 +39499,13 @@ func awsAwsquery_deserializeDocumentInvalidDBSecurityGroupStateFault(v **types.I return nil } -func awsAwsquery_deserializeDocumentInvalidDBSnapshotStateFault(v **types.InvalidDBSnapshotStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBClusterSnapshotStateFault(v **types.InvalidDBClusterSnapshotStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBSnapshotStateFault + var sv *types.InvalidDBClusterSnapshotStateFault if *v == nil { - sv = &types.InvalidDBSnapshotStateFault{} + sv = &types.InvalidDBClusterSnapshotStateFault{} } else { sv = *v } @@ -38709,13 +39548,13 @@ func awsAwsquery_deserializeDocumentInvalidDBSnapshotStateFault(v **types.Invali return nil } -func awsAwsquery_deserializeDocumentInvalidDBSubnetGroupFault(v **types.InvalidDBSubnetGroupFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBClusterStateFault(v **types.InvalidDBClusterStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBSubnetGroupFault + var sv *types.InvalidDBClusterStateFault if *v == nil { - sv = &types.InvalidDBSubnetGroupFault{} + sv = &types.InvalidDBClusterStateFault{} } else { sv = *v } @@ -38758,13 +39597,13 @@ func awsAwsquery_deserializeDocumentInvalidDBSubnetGroupFault(v **types.InvalidD return nil } -func awsAwsquery_deserializeDocumentInvalidDBSubnetGroupStateFault(v **types.InvalidDBSubnetGroupStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBInstanceAutomatedBackupStateFault(v **types.InvalidDBInstanceAutomatedBackupStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBSubnetGroupStateFault + var sv *types.InvalidDBInstanceAutomatedBackupStateFault if *v == nil { - sv = &types.InvalidDBSubnetGroupStateFault{} + sv = &types.InvalidDBInstanceAutomatedBackupStateFault{} } else { sv = *v } @@ -38807,13 +39646,13 @@ func awsAwsquery_deserializeDocumentInvalidDBSubnetGroupStateFault(v **types.Inv return nil } -func awsAwsquery_deserializeDocumentInvalidDBSubnetStateFault(v **types.InvalidDBSubnetStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBInstanceStateFault(v **types.InvalidDBInstanceStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidDBSubnetStateFault + var sv *types.InvalidDBInstanceStateFault if *v == nil { - sv = &types.InvalidDBSubnetStateFault{} + sv = &types.InvalidDBInstanceStateFault{} } else { sv = *v } @@ -38856,13 +39695,13 @@ func awsAwsquery_deserializeDocumentInvalidDBSubnetStateFault(v **types.InvalidD return nil } -func awsAwsquery_deserializeDocumentInvalidEventSubscriptionStateFault(v **types.InvalidEventSubscriptionStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBParameterGroupStateFault(v **types.InvalidDBParameterGroupStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidEventSubscriptionStateFault + var sv *types.InvalidDBParameterGroupStateFault if *v == nil { - sv = &types.InvalidEventSubscriptionStateFault{} + sv = &types.InvalidDBParameterGroupStateFault{} } else { sv = *v } @@ -38905,13 +39744,13 @@ func awsAwsquery_deserializeDocumentInvalidEventSubscriptionStateFault(v **types return nil } -func awsAwsquery_deserializeDocumentInvalidExportOnlyFault(v **types.InvalidExportOnlyFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBProxyEndpointStateFault(v **types.InvalidDBProxyEndpointStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidExportOnlyFault + var sv *types.InvalidDBProxyEndpointStateFault if *v == nil { - sv = &types.InvalidExportOnlyFault{} + sv = &types.InvalidDBProxyEndpointStateFault{} } else { sv = *v } @@ -38954,13 +39793,13 @@ func awsAwsquery_deserializeDocumentInvalidExportOnlyFault(v **types.InvalidExpo return nil } -func awsAwsquery_deserializeDocumentInvalidExportSourceStateFault(v **types.InvalidExportSourceStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBProxyStateFault(v **types.InvalidDBProxyStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidExportSourceStateFault + var sv *types.InvalidDBProxyStateFault if *v == nil { - sv = &types.InvalidExportSourceStateFault{} + sv = &types.InvalidDBProxyStateFault{} } else { sv = *v } @@ -39003,13 +39842,13 @@ func awsAwsquery_deserializeDocumentInvalidExportSourceStateFault(v **types.Inva return nil } -func awsAwsquery_deserializeDocumentInvalidExportTaskStateFault(v **types.InvalidExportTaskStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBSecurityGroupStateFault(v **types.InvalidDBSecurityGroupStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidExportTaskStateFault + var sv *types.InvalidDBSecurityGroupStateFault if *v == nil { - sv = &types.InvalidExportTaskStateFault{} + sv = &types.InvalidDBSecurityGroupStateFault{} } else { sv = *v } @@ -39052,13 +39891,13 @@ func awsAwsquery_deserializeDocumentInvalidExportTaskStateFault(v **types.Invali return nil } -func awsAwsquery_deserializeDocumentInvalidGlobalClusterStateFault(v **types.InvalidGlobalClusterStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBSnapshotStateFault(v **types.InvalidDBSnapshotStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidGlobalClusterStateFault + var sv *types.InvalidDBSnapshotStateFault if *v == nil { - sv = &types.InvalidGlobalClusterStateFault{} + sv = &types.InvalidDBSnapshotStateFault{} } else { sv = *v } @@ -39101,13 +39940,13 @@ func awsAwsquery_deserializeDocumentInvalidGlobalClusterStateFault(v **types.Inv return nil } -func awsAwsquery_deserializeDocumentInvalidOptionGroupStateFault(v **types.InvalidOptionGroupStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBSubnetGroupFault(v **types.InvalidDBSubnetGroupFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidOptionGroupStateFault + var sv *types.InvalidDBSubnetGroupFault if *v == nil { - sv = &types.InvalidOptionGroupStateFault{} + sv = &types.InvalidDBSubnetGroupFault{} } else { sv = *v } @@ -39150,13 +39989,13 @@ func awsAwsquery_deserializeDocumentInvalidOptionGroupStateFault(v **types.Inval return nil } -func awsAwsquery_deserializeDocumentInvalidRestoreFault(v **types.InvalidRestoreFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBSubnetGroupStateFault(v **types.InvalidDBSubnetGroupStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidRestoreFault + var sv *types.InvalidDBSubnetGroupStateFault if *v == nil { - sv = &types.InvalidRestoreFault{} + sv = &types.InvalidDBSubnetGroupStateFault{} } else { sv = *v } @@ -39199,13 +40038,13 @@ func awsAwsquery_deserializeDocumentInvalidRestoreFault(v **types.InvalidRestore return nil } -func awsAwsquery_deserializeDocumentInvalidS3BucketFault(v **types.InvalidS3BucketFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidDBSubnetStateFault(v **types.InvalidDBSubnetStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidS3BucketFault + var sv *types.InvalidDBSubnetStateFault if *v == nil { - sv = &types.InvalidS3BucketFault{} + sv = &types.InvalidDBSubnetStateFault{} } else { sv = *v } @@ -39248,13 +40087,13 @@ func awsAwsquery_deserializeDocumentInvalidS3BucketFault(v **types.InvalidS3Buck return nil } -func awsAwsquery_deserializeDocumentInvalidSubnet(v **types.InvalidSubnet, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidEventSubscriptionStateFault(v **types.InvalidEventSubscriptionStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidSubnet + var sv *types.InvalidEventSubscriptionStateFault if *v == nil { - sv = &types.InvalidSubnet{} + sv = &types.InvalidEventSubscriptionStateFault{} } else { sv = *v } @@ -39297,13 +40136,13 @@ func awsAwsquery_deserializeDocumentInvalidSubnet(v **types.InvalidSubnet, decod return nil } -func awsAwsquery_deserializeDocumentInvalidVPCNetworkStateFault(v **types.InvalidVPCNetworkStateFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidExportOnlyFault(v **types.InvalidExportOnlyFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.InvalidVPCNetworkStateFault + var sv *types.InvalidExportOnlyFault if *v == nil { - sv = &types.InvalidVPCNetworkStateFault{} + sv = &types.InvalidExportOnlyFault{} } else { sv = *v } @@ -39346,13 +40185,13 @@ func awsAwsquery_deserializeDocumentInvalidVPCNetworkStateFault(v **types.Invali return nil } -func awsAwsquery_deserializeDocumentIPRange(v **types.IPRange, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidExportSourceStateFault(v **types.InvalidExportSourceStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.IPRange + var sv *types.InvalidExportSourceStateFault if *v == nil { - sv = &types.IPRange{} + sv = &types.InvalidExportSourceStateFault{} } else { sv = *v } @@ -39368,20 +40207,7 @@ func awsAwsquery_deserializeDocumentIPRange(v **types.IPRange, decoder smithyxml originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("CIDRIP", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.CIDRIP = ptr.String(xtv) - } - - case strings.EqualFold("Status", t.Name.Local): + case strings.EqualFold("message", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -39391,7 +40217,7 @@ func awsAwsquery_deserializeDocumentIPRange(v **types.IPRange, decoder smithyxml } { xtv := string(val) - sv.Status = ptr.String(xtv) + sv.Message = ptr.String(xtv) } default: @@ -39408,18 +40234,17 @@ func awsAwsquery_deserializeDocumentIPRange(v **types.IPRange, decoder smithyxml return nil } -func awsAwsquery_deserializeDocumentIPRangeList(v *[]types.IPRange, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidExportTaskStateFault(v **types.InvalidExportTaskStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv []types.IPRange + var sv *types.InvalidExportTaskStateFault if *v == nil { - sv = make([]types.IPRange, 0) + sv = &types.InvalidExportTaskStateFault{} } else { sv = *v } - originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { @@ -39428,18 +40253,24 @@ func awsAwsquery_deserializeDocumentIPRangeList(v *[]types.IPRange, decoder smit if done { break } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("IPRange", t.Name.Local): - var col types.IPRange - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - destAddr := &col - if err := awsAwsquery_deserializeDocumentIPRange(&destAddr, nodeDecoder); err != nil { + case strings.EqualFold("message", t.Name.Local): + val, err := decoder.Value() + if err != nil { return err } - col = *destAddr - sv = append(sv, col) + if val == nil { + break + } + { + xtv := string(val) + sv.Message = ptr.String(xtv) + } default: + // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err @@ -39452,37 +40283,13 @@ func awsAwsquery_deserializeDocumentIPRangeList(v *[]types.IPRange, decoder smit return nil } -func awsAwsquery_deserializeDocumentIPRangeListUnwrapped(v *[]types.IPRange, decoder smithyxml.NodeDecoder) error { - var sv []types.IPRange - if *v == nil { - sv = make([]types.IPRange, 0) - } else { - sv = *v - } - - switch { - default: - var mv types.IPRange - t := decoder.StartEl - _ = t - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - destAddr := &mv - if err := awsAwsquery_deserializeDocumentIPRange(&destAddr, nodeDecoder); err != nil { - return err - } - mv = *destAddr - sv = append(sv, mv) - } - *v = sv - return nil -} -func awsAwsquery_deserializeDocumentKMSKeyNotAccessibleFault(v **types.KMSKeyNotAccessibleFault, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidGlobalClusterStateFault(v **types.InvalidGlobalClusterStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.KMSKeyNotAccessibleFault + var sv *types.InvalidGlobalClusterStateFault if *v == nil { - sv = &types.KMSKeyNotAccessibleFault{} + sv = &types.InvalidGlobalClusterStateFault{} } else { sv = *v } @@ -39525,18 +40332,17 @@ func awsAwsquery_deserializeDocumentKMSKeyNotAccessibleFault(v **types.KMSKeyNot return nil } -func awsAwsquery_deserializeDocumentLogTypeList(v *[]string, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidIntegrationStateFault(v **types.InvalidIntegrationStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv []string + var sv *types.InvalidIntegrationStateFault if *v == nil { - sv = make([]string, 0) + sv = &types.InvalidIntegrationStateFault{} } else { sv = *v } - originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { @@ -39545,11 +40351,10 @@ func awsAwsquery_deserializeDocumentLogTypeList(v *[]string, decoder smithyxml.N if done { break } - memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - decoder = memberDecoder + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("member", t.Name.Local): - var col string + case strings.EqualFold("message", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -39559,11 +40364,11 @@ func awsAwsquery_deserializeDocumentLogTypeList(v *[]string, decoder smithyxml.N } { xtv := string(val) - col = xtv + sv.Message = ptr.String(xtv) } - sv = append(sv, col) default: + // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err @@ -39576,42 +40381,13 @@ func awsAwsquery_deserializeDocumentLogTypeList(v *[]string, decoder smithyxml.N return nil } -func awsAwsquery_deserializeDocumentLogTypeListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { - var sv []string - if *v == nil { - sv = make([]string, 0) - } else { - sv = *v - } - - switch { - default: - var mv string - t := decoder.StartEl - _ = t - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - mv = xtv - } - sv = append(sv, mv) - } - *v = sv - return nil -} -func awsAwsquery_deserializeDocumentMasterUserSecret(v **types.MasterUserSecret, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidOptionGroupStateFault(v **types.InvalidOptionGroupStateFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.MasterUserSecret + var sv *types.InvalidOptionGroupStateFault if *v == nil { - sv = &types.MasterUserSecret{} + sv = &types.InvalidOptionGroupStateFault{} } else { sv = *v } @@ -39627,33 +40403,7 @@ func awsAwsquery_deserializeDocumentMasterUserSecret(v **types.MasterUserSecret, originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("KmsKeyId", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.KmsKeyId = ptr.String(xtv) - } - - case strings.EqualFold("SecretArn", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.SecretArn = ptr.String(xtv) - } - - case strings.EqualFold("SecretStatus", t.Name.Local): + case strings.EqualFold("message", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -39663,7 +40413,7 @@ func awsAwsquery_deserializeDocumentMasterUserSecret(v **types.MasterUserSecret, } { xtv := string(val) - sv.SecretStatus = ptr.String(xtv) + sv.Message = ptr.String(xtv) } default: @@ -39680,13 +40430,13 @@ func awsAwsquery_deserializeDocumentMasterUserSecret(v **types.MasterUserSecret, return nil } -func awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValue(v **types.MinimumEngineVersionPerAllowedValue, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidRestoreFault(v **types.InvalidRestoreFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.MinimumEngineVersionPerAllowedValue + var sv *types.InvalidRestoreFault if *v == nil { - sv = &types.MinimumEngineVersionPerAllowedValue{} + sv = &types.InvalidRestoreFault{} } else { sv = *v } @@ -39702,20 +40452,7 @@ func awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValue(v **type originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("AllowedValue", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.AllowedValue = ptr.String(xtv) - } - - case strings.EqualFold("MinimumEngineVersion", t.Name.Local): + case strings.EqualFold("message", t.Name.Local): val, err := decoder.Value() if err != nil { return err @@ -39725,7 +40462,7 @@ func awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValue(v **type } { xtv := string(val) - sv.MinimumEngineVersion = ptr.String(xtv) + sv.Message = ptr.String(xtv) } default: @@ -39742,18 +40479,17 @@ func awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValue(v **type return nil } -func awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValueList(v *[]types.MinimumEngineVersionPerAllowedValue, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidS3BucketFault(v **types.InvalidS3BucketFault, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv []types.MinimumEngineVersionPerAllowedValue + var sv *types.InvalidS3BucketFault if *v == nil { - sv = make([]types.MinimumEngineVersionPerAllowedValue, 0) + sv = &types.InvalidS3BucketFault{} } else { sv = *v } - originalDecoder := decoder for { t, done, err := decoder.Token() if err != nil { @@ -39762,18 +40498,24 @@ func awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValueList(v *[ if done { break } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("MinimumEngineVersionPerAllowedValue", t.Name.Local): - var col types.MinimumEngineVersionPerAllowedValue - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - destAddr := &col - if err := awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValue(&destAddr, nodeDecoder); err != nil { + case strings.EqualFold("message", t.Name.Local): + val, err := decoder.Value() + if err != nil { return err } - col = *destAddr - sv = append(sv, col) + if val == nil { + break + } + { + xtv := string(val) + sv.Message = ptr.String(xtv) + } default: + // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() if err != nil { return err @@ -39786,37 +40528,575 @@ func awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValueList(v *[ return nil } -func awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValueListUnwrapped(v *[]types.MinimumEngineVersionPerAllowedValue, decoder smithyxml.NodeDecoder) error { - var sv []types.MinimumEngineVersionPerAllowedValue - if *v == nil { - sv = make([]types.MinimumEngineVersionPerAllowedValue, 0) - } else { - sv = *v - } - - switch { - default: - var mv types.MinimumEngineVersionPerAllowedValue - t := decoder.StartEl - _ = t - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - destAddr := &mv - if err := awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValue(&destAddr, nodeDecoder); err != nil { - return err - } - mv = *destAddr - sv = append(sv, mv) - } - *v = sv - return nil -} -func awsAwsquery_deserializeDocumentNetworkTypeNotSupported(v **types.NetworkTypeNotSupported, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeDocumentInvalidSubnet(v **types.InvalidSubnet, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *types.NetworkTypeNotSupported + var sv *types.InvalidSubnet if *v == nil { - sv = &types.NetworkTypeNotSupported{} + sv = &types.InvalidSubnet{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("message", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Message = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentInvalidVPCNetworkStateFault(v **types.InvalidVPCNetworkStateFault, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.InvalidVPCNetworkStateFault + if *v == nil { + sv = &types.InvalidVPCNetworkStateFault{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("message", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Message = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentIPRange(v **types.IPRange, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.IPRange + if *v == nil { + sv = &types.IPRange{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("CIDRIP", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.CIDRIP = ptr.String(xtv) + } + + case strings.EqualFold("Status", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Status = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentIPRangeList(v *[]types.IPRange, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.IPRange + if *v == nil { + sv = make([]types.IPRange, 0) + } else { + sv = *v + } + + originalDecoder := decoder + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + switch { + case strings.EqualFold("IPRange", t.Name.Local): + var col types.IPRange + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsAwsquery_deserializeDocumentIPRange(&destAddr, nodeDecoder); err != nil { + return err + } + col = *destAddr + sv = append(sv, col) + + default: + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentIPRangeListUnwrapped(v *[]types.IPRange, decoder smithyxml.NodeDecoder) error { + var sv []types.IPRange + if *v == nil { + sv = make([]types.IPRange, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.IPRange + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsAwsquery_deserializeDocumentIPRange(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsAwsquery_deserializeDocumentKMSKeyNotAccessibleFault(v **types.KMSKeyNotAccessibleFault, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.KMSKeyNotAccessibleFault + if *v == nil { + sv = &types.KMSKeyNotAccessibleFault{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("message", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Message = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentLogTypeList(v *[]string, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []string + if *v == nil { + sv = make([]string, 0) + } else { + sv = *v + } + + originalDecoder := decoder + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + decoder = memberDecoder + switch { + case strings.EqualFold("member", t.Name.Local): + var col string + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + col = xtv + } + sv = append(sv, col) + + default: + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentLogTypeListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { + var sv []string + if *v == nil { + sv = make([]string, 0) + } else { + sv = *v + } + + switch { + default: + var mv string + t := decoder.StartEl + _ = t + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + mv = xtv + } + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsAwsquery_deserializeDocumentMasterUserSecret(v **types.MasterUserSecret, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.MasterUserSecret + if *v == nil { + sv = &types.MasterUserSecret{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("KmsKeyId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.KmsKeyId = ptr.String(xtv) + } + + case strings.EqualFold("SecretArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SecretArn = ptr.String(xtv) + } + + case strings.EqualFold("SecretStatus", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SecretStatus = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValue(v **types.MinimumEngineVersionPerAllowedValue, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.MinimumEngineVersionPerAllowedValue + if *v == nil { + sv = &types.MinimumEngineVersionPerAllowedValue{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("AllowedValue", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.AllowedValue = ptr.String(xtv) + } + + case strings.EqualFold("MinimumEngineVersion", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.MinimumEngineVersion = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValueList(v *[]types.MinimumEngineVersionPerAllowedValue, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.MinimumEngineVersionPerAllowedValue + if *v == nil { + sv = make([]types.MinimumEngineVersionPerAllowedValue, 0) + } else { + sv = *v + } + + originalDecoder := decoder + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + switch { + case strings.EqualFold("MinimumEngineVersionPerAllowedValue", t.Name.Local): + var col types.MinimumEngineVersionPerAllowedValue + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &col + if err := awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValue(&destAddr, nodeDecoder); err != nil { + return err + } + col = *destAddr + sv = append(sv, col) + + default: + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValueListUnwrapped(v *[]types.MinimumEngineVersionPerAllowedValue, decoder smithyxml.NodeDecoder) error { + var sv []types.MinimumEngineVersionPerAllowedValue + if *v == nil { + sv = make([]types.MinimumEngineVersionPerAllowedValue, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.MinimumEngineVersionPerAllowedValue + t := decoder.StartEl + _ = t + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + destAddr := &mv + if err := awsAwsquery_deserializeDocumentMinimumEngineVersionPerAllowedValue(&destAddr, nodeDecoder); err != nil { + return err + } + mv = *destAddr + sv = append(sv, mv) + } + *v = sv + return nil +} +func awsAwsquery_deserializeDocumentNetworkTypeNotSupported(v **types.NetworkTypeNotSupported, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.NetworkTypeNotSupported + if *v == nil { + sv = &types.NetworkTypeNotSupported{} } else { sv = *v } @@ -47170,6 +48450,22 @@ func awsAwsquery_deserializeDocumentUpgradeTarget(v **types.UpgradeTarget, decod sv.SupportsGlobalDatabases = ptr.Bool(xtv) } + case strings.EqualFold("SupportsIntegrations", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv, err := strconv.ParseBool(string(val)) + if err != nil { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val) + } + sv.SupportsIntegrations = ptr.Bool(xtv) + } + case strings.EqualFold("SupportsLocalWriteForwarding", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -48894,6 +50190,22 @@ func awsAwsquery_deserializeOpDocumentCreateCustomDBEngineVersionOutput(v **Crea sv.SupportsGlobalDatabases = ptr.Bool(xtv) } + case strings.EqualFold("SupportsIntegrations", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv, err := strconv.ParseBool(string(val)) + if err != nil { + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) + } + sv.SupportsIntegrations = ptr.Bool(xtv) + } + case strings.EqualFold("SupportsLocalWriteForwarding", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -49682,6 +50994,155 @@ func awsAwsquery_deserializeOpDocumentCreateGlobalClusterOutput(v **CreateGlobal return nil } +func awsAwsquery_deserializeOpDocumentCreateIntegrationOutput(v **CreateIntegrationOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *CreateIntegrationOutput + if *v == nil { + sv = &CreateIntegrationOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("AdditionalEncryptionContext", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentEncryptionContextMap(&sv.AdditionalEncryptionContext, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("CreateTime", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + t, err := smithytime.ParseDateTime(xtv) + if err != nil { + return err + } + sv.CreateTime = ptr.Time(t) + } + + case strings.EqualFold("Errors", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentIntegrationErrorList(&sv.Errors, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("IntegrationArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IntegrationArn = ptr.String(xtv) + } + + case strings.EqualFold("IntegrationName", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IntegrationName = ptr.String(xtv) + } + + case strings.EqualFold("KMSKeyId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.KMSKeyId = ptr.String(xtv) + } + + case strings.EqualFold("SourceArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SourceArn = ptr.String(xtv) + } + + case strings.EqualFold("Status", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Status = types.IntegrationStatus(xtv) + } + + case strings.EqualFold("Tags", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("TargetArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.TargetArn = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsAwsquery_deserializeOpDocumentCreateOptionGroupOutput(v **CreateOptionGroupOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -50076,6 +51537,22 @@ func awsAwsquery_deserializeOpDocumentDeleteCustomDBEngineVersionOutput(v **Dele sv.SupportsGlobalDatabases = ptr.Bool(xtv) } + case strings.EqualFold("SupportsIntegrations", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv, err := strconv.ParseBool(string(val)) + if err != nil { + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) + } + sv.SupportsIntegrations = ptr.Bool(xtv) + } + case strings.EqualFold("SupportsLocalWriteForwarding", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -50738,6 +52215,155 @@ func awsAwsquery_deserializeOpDocumentDeleteGlobalClusterOutput(v **DeleteGlobal return nil } +func awsAwsquery_deserializeOpDocumentDeleteIntegrationOutput(v **DeleteIntegrationOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DeleteIntegrationOutput + if *v == nil { + sv = &DeleteIntegrationOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("AdditionalEncryptionContext", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentEncryptionContextMap(&sv.AdditionalEncryptionContext, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("CreateTime", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + t, err := smithytime.ParseDateTime(xtv) + if err != nil { + return err + } + sv.CreateTime = ptr.Time(t) + } + + case strings.EqualFold("Errors", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentIntegrationErrorList(&sv.Errors, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("IntegrationArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IntegrationArn = ptr.String(xtv) + } + + case strings.EqualFold("IntegrationName", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.IntegrationName = ptr.String(xtv) + } + + case strings.EqualFold("KMSKeyId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.KMSKeyId = ptr.String(xtv) + } + + case strings.EqualFold("SourceArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.SourceArn = ptr.String(xtv) + } + + case strings.EqualFold("Status", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Status = types.IntegrationStatus(xtv) + } + + case strings.EqualFold("Tags", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("TargetArn", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.TargetArn = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsAwsquery_deserializeOpDocumentDeregisterDBProxyTargetsOutput(v **DeregisterDBProxyTargetsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -50939,13 +52565,233 @@ func awsAwsquery_deserializeOpDocumentDescribeCertificatesOutput(v **DescribeCer return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBClusterAutomatedBackupsOutput(v **DescribeDBClusterAutomatedBackupsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBClusterAutomatedBackupsOutput(v **DescribeDBClusterAutomatedBackupsOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DescribeDBClusterAutomatedBackupsOutput + if *v == nil { + sv = &DescribeDBClusterAutomatedBackupsOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("DBClusterAutomatedBackups", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentDBClusterAutomatedBackupList(&sv.DBClusterAutomatedBackups, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("Marker", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Marker = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeOpDocumentDescribeDBClusterBacktracksOutput(v **DescribeDBClusterBacktracksOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DescribeDBClusterBacktracksOutput + if *v == nil { + sv = &DescribeDBClusterBacktracksOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("DBClusterBacktracks", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentDBClusterBacktrackList(&sv.DBClusterBacktracks, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("Marker", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Marker = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeOpDocumentDescribeDBClusterEndpointsOutput(v **DescribeDBClusterEndpointsOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DescribeDBClusterEndpointsOutput + if *v == nil { + sv = &DescribeDBClusterEndpointsOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("DBClusterEndpoints", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentDBClusterEndpointList(&sv.DBClusterEndpoints, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("Marker", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Marker = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeOpDocumentDescribeDBClusterParameterGroupsOutput(v **DescribeDBClusterParameterGroupsOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DescribeDBClusterParameterGroupsOutput + if *v == nil { + sv = &DescribeDBClusterParameterGroupsOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("DBClusterParameterGroups", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentDBClusterParameterGroupList(&sv.DBClusterParameterGroups, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("Marker", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Marker = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeOpDocumentDescribeDBClusterParametersOutput(v **DescribeDBClusterParametersOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBClusterAutomatedBackupsOutput + var sv *DescribeDBClusterParametersOutput if *v == nil { - sv = &DescribeDBClusterAutomatedBackupsOutput{} + sv = &DescribeDBClusterParametersOutput{} } else { sv = *v } @@ -50961,12 +52807,6 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterAutomatedBackupsOutput(v originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBClusterAutomatedBackups", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBClusterAutomatedBackupList(&sv.DBClusterAutomatedBackups, nodeDecoder); err != nil { - return err - } - case strings.EqualFold("Marker", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -50980,6 +52820,12 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterAutomatedBackupsOutput(v sv.Marker = ptr.String(xtv) } + case strings.EqualFold("Parameters", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentParametersList(&sv.Parameters, nodeDecoder); err != nil { + return err + } + default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() @@ -50994,13 +52840,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterAutomatedBackupsOutput(v return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBClusterBacktracksOutput(v **DescribeDBClusterBacktracksOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotAttributesOutput(v **DescribeDBClusterSnapshotAttributesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBClusterBacktracksOutput + var sv *DescribeDBClusterSnapshotAttributesOutput if *v == nil { - sv = &DescribeDBClusterBacktracksOutput{} + sv = &DescribeDBClusterSnapshotAttributesOutput{} } else { sv = *v } @@ -51016,24 +52862,11 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterBacktracksOutput(v **Desc originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBClusterBacktracks", t.Name.Local): + case strings.EqualFold("DBClusterSnapshotAttributesResult", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBClusterBacktrackList(&sv.DBClusterBacktracks, nodeDecoder); err != nil { - return err - } - - case strings.EqualFold("Marker", t.Name.Local): - val, err := decoder.Value() - if err != nil { + if err := awsAwsquery_deserializeDocumentDBClusterSnapshotAttributesResult(&sv.DBClusterSnapshotAttributesResult, nodeDecoder); err != nil { return err } - if val == nil { - break - } - { - xtv := string(val) - sv.Marker = ptr.String(xtv) - } default: // Do nothing and ignore the unexpected tag element @@ -51049,13 +52882,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterBacktracksOutput(v **Desc return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBClusterEndpointsOutput(v **DescribeDBClusterEndpointsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotsOutput(v **DescribeDBClusterSnapshotsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBClusterEndpointsOutput + var sv *DescribeDBClusterSnapshotsOutput if *v == nil { - sv = &DescribeDBClusterEndpointsOutput{} + sv = &DescribeDBClusterSnapshotsOutput{} } else { sv = *v } @@ -51071,9 +52904,9 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterEndpointsOutput(v **Descr originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBClusterEndpoints", t.Name.Local): + case strings.EqualFold("DBClusterSnapshots", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBClusterEndpointList(&sv.DBClusterEndpoints, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentDBClusterSnapshotList(&sv.DBClusterSnapshots, nodeDecoder); err != nil { return err } @@ -51104,13 +52937,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterEndpointsOutput(v **Descr return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBClusterParameterGroupsOutput(v **DescribeDBClusterParameterGroupsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBClustersOutput(v **DescribeDBClustersOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBClusterParameterGroupsOutput + var sv *DescribeDBClustersOutput if *v == nil { - sv = &DescribeDBClusterParameterGroupsOutput{} + sv = &DescribeDBClustersOutput{} } else { sv = *v } @@ -51126,9 +52959,9 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterParameterGroupsOutput(v * originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBClusterParameterGroups", t.Name.Local): + case strings.EqualFold("DBClusters", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBClusterParameterGroupList(&sv.DBClusterParameterGroups, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentDBClusterList(&sv.DBClusters, nodeDecoder); err != nil { return err } @@ -51159,13 +52992,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterParameterGroupsOutput(v * return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBClusterParametersOutput(v **DescribeDBClusterParametersOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBEngineVersionsOutput(v **DescribeDBEngineVersionsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBClusterParametersOutput + var sv *DescribeDBEngineVersionsOutput if *v == nil { - sv = &DescribeDBClusterParametersOutput{} + sv = &DescribeDBEngineVersionsOutput{} } else { sv = *v } @@ -51181,6 +53014,12 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterParametersOutput(v **Desc originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { + case strings.EqualFold("DBEngineVersions", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentDBEngineVersionList(&sv.DBEngineVersions, nodeDecoder); err != nil { + return err + } + case strings.EqualFold("Marker", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -51194,12 +53033,6 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterParametersOutput(v **Desc sv.Marker = ptr.String(xtv) } - case strings.EqualFold("Parameters", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentParametersList(&sv.Parameters, nodeDecoder); err != nil { - return err - } - default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() @@ -51214,13 +53047,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterParametersOutput(v **Desc return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotAttributesOutput(v **DescribeDBClusterSnapshotAttributesOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBInstanceAutomatedBackupsOutput(v **DescribeDBInstanceAutomatedBackupsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBClusterSnapshotAttributesOutput + var sv *DescribeDBInstanceAutomatedBackupsOutput if *v == nil { - sv = &DescribeDBClusterSnapshotAttributesOutput{} + sv = &DescribeDBInstanceAutomatedBackupsOutput{} } else { sv = *v } @@ -51236,12 +53069,25 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotAttributesOutput( originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBClusterSnapshotAttributesResult", t.Name.Local): + case strings.EqualFold("DBInstanceAutomatedBackups", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBClusterSnapshotAttributesResult(&sv.DBClusterSnapshotAttributesResult, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentDBInstanceAutomatedBackupList(&sv.DBInstanceAutomatedBackups, nodeDecoder); err != nil { return err } + case strings.EqualFold("Marker", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.Marker = ptr.String(xtv) + } + default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() @@ -51256,13 +53102,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotAttributesOutput( return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotsOutput(v **DescribeDBClusterSnapshotsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBInstancesOutput(v **DescribeDBInstancesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBClusterSnapshotsOutput + var sv *DescribeDBInstancesOutput if *v == nil { - sv = &DescribeDBClusterSnapshotsOutput{} + sv = &DescribeDBInstancesOutput{} } else { sv = *v } @@ -51278,9 +53124,9 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotsOutput(v **Descr originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBClusterSnapshots", t.Name.Local): + case strings.EqualFold("DBInstances", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBClusterSnapshotList(&sv.DBClusterSnapshots, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentDBInstanceList(&sv.DBInstances, nodeDecoder); err != nil { return err } @@ -51311,13 +53157,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotsOutput(v **Descr return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBClustersOutput(v **DescribeDBClustersOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBLogFilesOutput(v **DescribeDBLogFilesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBClustersOutput + var sv *DescribeDBLogFilesOutput if *v == nil { - sv = &DescribeDBClustersOutput{} + sv = &DescribeDBLogFilesOutput{} } else { sv = *v } @@ -51333,9 +53179,9 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClustersOutput(v **DescribeDBClu originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBClusters", t.Name.Local): + case strings.EqualFold("DescribeDBLogFiles", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBClusterList(&sv.DBClusters, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentDescribeDBLogFilesList(&sv.DescribeDBLogFiles, nodeDecoder); err != nil { return err } @@ -51366,13 +53212,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBClustersOutput(v **DescribeDBClu return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBEngineVersionsOutput(v **DescribeDBEngineVersionsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBParameterGroupsOutput(v **DescribeDBParameterGroupsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBEngineVersionsOutput + var sv *DescribeDBParameterGroupsOutput if *v == nil { - sv = &DescribeDBEngineVersionsOutput{} + sv = &DescribeDBParameterGroupsOutput{} } else { sv = *v } @@ -51388,9 +53234,9 @@ func awsAwsquery_deserializeOpDocumentDescribeDBEngineVersionsOutput(v **Describ originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBEngineVersions", t.Name.Local): + case strings.EqualFold("DBParameterGroups", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBEngineVersionList(&sv.DBEngineVersions, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentDBParameterGroupList(&sv.DBParameterGroups, nodeDecoder); err != nil { return err } @@ -51421,13 +53267,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBEngineVersionsOutput(v **Describ return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBInstanceAutomatedBackupsOutput(v **DescribeDBInstanceAutomatedBackupsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBParametersOutput(v **DescribeDBParametersOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBInstanceAutomatedBackupsOutput + var sv *DescribeDBParametersOutput if *v == nil { - sv = &DescribeDBInstanceAutomatedBackupsOutput{} + sv = &DescribeDBParametersOutput{} } else { sv = *v } @@ -51443,12 +53289,6 @@ func awsAwsquery_deserializeOpDocumentDescribeDBInstanceAutomatedBackupsOutput(v originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBInstanceAutomatedBackups", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBInstanceAutomatedBackupList(&sv.DBInstanceAutomatedBackups, nodeDecoder); err != nil { - return err - } - case strings.EqualFold("Marker", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -51462,6 +53302,12 @@ func awsAwsquery_deserializeOpDocumentDescribeDBInstanceAutomatedBackupsOutput(v sv.Marker = ptr.String(xtv) } + case strings.EqualFold("Parameters", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentParametersList(&sv.Parameters, nodeDecoder); err != nil { + return err + } + default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() @@ -51476,13 +53322,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBInstanceAutomatedBackupsOutput(v return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBInstancesOutput(v **DescribeDBInstancesOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBProxiesOutput(v **DescribeDBProxiesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBInstancesOutput + var sv *DescribeDBProxiesOutput if *v == nil { - sv = &DescribeDBInstancesOutput{} + sv = &DescribeDBProxiesOutput{} } else { sv = *v } @@ -51498,9 +53344,9 @@ func awsAwsquery_deserializeOpDocumentDescribeDBInstancesOutput(v **DescribeDBIn originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBInstances", t.Name.Local): + case strings.EqualFold("DBProxies", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBInstanceList(&sv.DBInstances, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentDBProxyList(&sv.DBProxies, nodeDecoder); err != nil { return err } @@ -51531,13 +53377,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBInstancesOutput(v **DescribeDBIn return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBLogFilesOutput(v **DescribeDBLogFilesOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBProxyEndpointsOutput(v **DescribeDBProxyEndpointsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBLogFilesOutput + var sv *DescribeDBProxyEndpointsOutput if *v == nil { - sv = &DescribeDBLogFilesOutput{} + sv = &DescribeDBProxyEndpointsOutput{} } else { sv = *v } @@ -51553,9 +53399,9 @@ func awsAwsquery_deserializeOpDocumentDescribeDBLogFilesOutput(v **DescribeDBLog originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DescribeDBLogFiles", t.Name.Local): + case strings.EqualFold("DBProxyEndpoints", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDescribeDBLogFilesList(&sv.DescribeDBLogFiles, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentDBProxyEndpointList(&sv.DBProxyEndpoints, nodeDecoder); err != nil { return err } @@ -51586,13 +53432,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBLogFilesOutput(v **DescribeDBLog return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBParameterGroupsOutput(v **DescribeDBParameterGroupsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBProxyTargetGroupsOutput(v **DescribeDBProxyTargetGroupsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBParameterGroupsOutput + var sv *DescribeDBProxyTargetGroupsOutput if *v == nil { - sv = &DescribeDBParameterGroupsOutput{} + sv = &DescribeDBProxyTargetGroupsOutput{} } else { sv = *v } @@ -51608,12 +53454,6 @@ func awsAwsquery_deserializeOpDocumentDescribeDBParameterGroupsOutput(v **Descri originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBParameterGroups", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBParameterGroupList(&sv.DBParameterGroups, nodeDecoder); err != nil { - return err - } - case strings.EqualFold("Marker", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -51627,6 +53467,12 @@ func awsAwsquery_deserializeOpDocumentDescribeDBParameterGroupsOutput(v **Descri sv.Marker = ptr.String(xtv) } + case strings.EqualFold("TargetGroups", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentTargetGroupList(&sv.TargetGroups, nodeDecoder); err != nil { + return err + } + default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() @@ -51641,13 +53487,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBParameterGroupsOutput(v **Descri return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBParametersOutput(v **DescribeDBParametersOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBProxyTargetsOutput(v **DescribeDBProxyTargetsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBParametersOutput + var sv *DescribeDBProxyTargetsOutput if *v == nil { - sv = &DescribeDBParametersOutput{} + sv = &DescribeDBProxyTargetsOutput{} } else { sv = *v } @@ -51676,9 +53522,9 @@ func awsAwsquery_deserializeOpDocumentDescribeDBParametersOutput(v **DescribeDBP sv.Marker = ptr.String(xtv) } - case strings.EqualFold("Parameters", t.Name.Local): + case strings.EqualFold("Targets", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentParametersList(&sv.Parameters, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentTargetList(&sv.Targets, nodeDecoder); err != nil { return err } @@ -51696,13 +53542,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBParametersOutput(v **DescribeDBP return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBProxiesOutput(v **DescribeDBProxiesOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBSecurityGroupsOutput(v **DescribeDBSecurityGroupsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBProxiesOutput + var sv *DescribeDBSecurityGroupsOutput if *v == nil { - sv = &DescribeDBProxiesOutput{} + sv = &DescribeDBSecurityGroupsOutput{} } else { sv = *v } @@ -51718,9 +53564,9 @@ func awsAwsquery_deserializeOpDocumentDescribeDBProxiesOutput(v **DescribeDBProx originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBProxies", t.Name.Local): + case strings.EqualFold("DBSecurityGroups", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBProxyList(&sv.DBProxies, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentDBSecurityGroups(&sv.DBSecurityGroups, nodeDecoder); err != nil { return err } @@ -51751,13 +53597,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBProxiesOutput(v **DescribeDBProx return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBProxyEndpointsOutput(v **DescribeDBProxyEndpointsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBSnapshotAttributesOutput(v **DescribeDBSnapshotAttributesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBProxyEndpointsOutput + var sv *DescribeDBSnapshotAttributesOutput if *v == nil { - sv = &DescribeDBProxyEndpointsOutput{} + sv = &DescribeDBSnapshotAttributesOutput{} } else { sv = *v } @@ -51773,9 +53619,51 @@ func awsAwsquery_deserializeOpDocumentDescribeDBProxyEndpointsOutput(v **Describ originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBProxyEndpoints", t.Name.Local): + case strings.EqualFold("DBSnapshotAttributesResult", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBProxyEndpointList(&sv.DBProxyEndpoints, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentDBSnapshotAttributesResult(&sv.DBSnapshotAttributesResult, nodeDecoder); err != nil { + return err + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsAwsquery_deserializeOpDocumentDescribeDBSnapshotsOutput(v **DescribeDBSnapshotsOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *DescribeDBSnapshotsOutput + if *v == nil { + sv = &DescribeDBSnapshotsOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("DBSnapshots", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsAwsquery_deserializeDocumentDBSnapshotList(&sv.DBSnapshots, nodeDecoder); err != nil { return err } @@ -51806,13 +53694,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBProxyEndpointsOutput(v **Describ return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBProxyTargetGroupsOutput(v **DescribeDBProxyTargetGroupsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeDBSubnetGroupsOutput(v **DescribeDBSubnetGroupsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBProxyTargetGroupsOutput + var sv *DescribeDBSubnetGroupsOutput if *v == nil { - sv = &DescribeDBProxyTargetGroupsOutput{} + sv = &DescribeDBSubnetGroupsOutput{} } else { sv = *v } @@ -51828,61 +53716,12 @@ func awsAwsquery_deserializeOpDocumentDescribeDBProxyTargetGroupsOutput(v **Desc originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("Marker", t.Name.Local): - val, err := decoder.Value() - if err != nil { - return err - } - if val == nil { - break - } - { - xtv := string(val) - sv.Marker = ptr.String(xtv) - } - - case strings.EqualFold("TargetGroups", t.Name.Local): + case strings.EqualFold("DBSubnetGroups", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentTargetGroupList(&sv.TargetGroups, nodeDecoder); err != nil { - return err - } - - default: - // Do nothing and ignore the unexpected tag element - err = decoder.Decoder.Skip() - if err != nil { + if err := awsAwsquery_deserializeDocumentDBSubnetGroups(&sv.DBSubnetGroups, nodeDecoder); err != nil { return err } - } - decoder = originalDecoder - } - *v = sv - return nil -} - -func awsAwsquery_deserializeOpDocumentDescribeDBProxyTargetsOutput(v **DescribeDBProxyTargetsOutput, decoder smithyxml.NodeDecoder) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - var sv *DescribeDBProxyTargetsOutput - if *v == nil { - sv = &DescribeDBProxyTargetsOutput{} - } else { - sv = *v - } - - for { - t, done, err := decoder.Token() - if err != nil { - return err - } - if done { - break - } - originalDecoder := decoder - decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) - switch { case strings.EqualFold("Marker", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -51896,12 +53735,6 @@ func awsAwsquery_deserializeOpDocumentDescribeDBProxyTargetsOutput(v **DescribeD sv.Marker = ptr.String(xtv) } - case strings.EqualFold("Targets", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentTargetList(&sv.Targets, nodeDecoder); err != nil { - return err - } - default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() @@ -51916,13 +53749,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBProxyTargetsOutput(v **DescribeD return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBSecurityGroupsOutput(v **DescribeDBSecurityGroupsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeEngineDefaultClusterParametersOutput(v **DescribeEngineDefaultClusterParametersOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBSecurityGroupsOutput + var sv *DescribeEngineDefaultClusterParametersOutput if *v == nil { - sv = &DescribeDBSecurityGroupsOutput{} + sv = &DescribeEngineDefaultClusterParametersOutput{} } else { sv = *v } @@ -51938,24 +53771,11 @@ func awsAwsquery_deserializeOpDocumentDescribeDBSecurityGroupsOutput(v **Describ originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBSecurityGroups", t.Name.Local): + case strings.EqualFold("EngineDefaults", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBSecurityGroups(&sv.DBSecurityGroups, nodeDecoder); err != nil { - return err - } - - case strings.EqualFold("Marker", t.Name.Local): - val, err := decoder.Value() - if err != nil { + if err := awsAwsquery_deserializeDocumentEngineDefaults(&sv.EngineDefaults, nodeDecoder); err != nil { return err } - if val == nil { - break - } - { - xtv := string(val) - sv.Marker = ptr.String(xtv) - } default: // Do nothing and ignore the unexpected tag element @@ -51971,13 +53791,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBSecurityGroupsOutput(v **Describ return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBSnapshotAttributesOutput(v **DescribeDBSnapshotAttributesOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeEngineDefaultParametersOutput(v **DescribeEngineDefaultParametersOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBSnapshotAttributesOutput + var sv *DescribeEngineDefaultParametersOutput if *v == nil { - sv = &DescribeDBSnapshotAttributesOutput{} + sv = &DescribeEngineDefaultParametersOutput{} } else { sv = *v } @@ -51993,9 +53813,9 @@ func awsAwsquery_deserializeOpDocumentDescribeDBSnapshotAttributesOutput(v **Des originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBSnapshotAttributesResult", t.Name.Local): + case strings.EqualFold("EngineDefaults", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBSnapshotAttributesResult(&sv.DBSnapshotAttributesResult, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentEngineDefaults(&sv.EngineDefaults, nodeDecoder); err != nil { return err } @@ -52013,13 +53833,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBSnapshotAttributesOutput(v **Des return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBSnapshotsOutput(v **DescribeDBSnapshotsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeEventCategoriesOutput(v **DescribeEventCategoriesOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBSnapshotsOutput + var sv *DescribeEventCategoriesOutput if *v == nil { - sv = &DescribeDBSnapshotsOutput{} + sv = &DescribeEventCategoriesOutput{} } else { sv = *v } @@ -52035,24 +53855,11 @@ func awsAwsquery_deserializeOpDocumentDescribeDBSnapshotsOutput(v **DescribeDBSn originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBSnapshots", t.Name.Local): + case strings.EqualFold("EventCategoriesMapList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBSnapshotList(&sv.DBSnapshots, nodeDecoder); err != nil { - return err - } - - case strings.EqualFold("Marker", t.Name.Local): - val, err := decoder.Value() - if err != nil { + if err := awsAwsquery_deserializeDocumentEventCategoriesMapList(&sv.EventCategoriesMapList, nodeDecoder); err != nil { return err } - if val == nil { - break - } - { - xtv := string(val) - sv.Marker = ptr.String(xtv) - } default: // Do nothing and ignore the unexpected tag element @@ -52068,13 +53875,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBSnapshotsOutput(v **DescribeDBSn return nil } -func awsAwsquery_deserializeOpDocumentDescribeDBSubnetGroupsOutput(v **DescribeDBSubnetGroupsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeEventsOutput(v **DescribeEventsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeDBSubnetGroupsOutput + var sv *DescribeEventsOutput if *v == nil { - sv = &DescribeDBSubnetGroupsOutput{} + sv = &DescribeEventsOutput{} } else { sv = *v } @@ -52090,9 +53897,9 @@ func awsAwsquery_deserializeOpDocumentDescribeDBSubnetGroupsOutput(v **DescribeD originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("DBSubnetGroups", t.Name.Local): + case strings.EqualFold("Events", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentDBSubnetGroups(&sv.DBSubnetGroups, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentEventList(&sv.Events, nodeDecoder); err != nil { return err } @@ -52123,139 +53930,13 @@ func awsAwsquery_deserializeOpDocumentDescribeDBSubnetGroupsOutput(v **DescribeD return nil } -func awsAwsquery_deserializeOpDocumentDescribeEngineDefaultClusterParametersOutput(v **DescribeEngineDefaultClusterParametersOutput, decoder smithyxml.NodeDecoder) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - var sv *DescribeEngineDefaultClusterParametersOutput - if *v == nil { - sv = &DescribeEngineDefaultClusterParametersOutput{} - } else { - sv = *v - } - - for { - t, done, err := decoder.Token() - if err != nil { - return err - } - if done { - break - } - originalDecoder := decoder - decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) - switch { - case strings.EqualFold("EngineDefaults", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentEngineDefaults(&sv.EngineDefaults, nodeDecoder); err != nil { - return err - } - - default: - // Do nothing and ignore the unexpected tag element - err = decoder.Decoder.Skip() - if err != nil { - return err - } - - } - decoder = originalDecoder - } - *v = sv - return nil -} - -func awsAwsquery_deserializeOpDocumentDescribeEngineDefaultParametersOutput(v **DescribeEngineDefaultParametersOutput, decoder smithyxml.NodeDecoder) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - var sv *DescribeEngineDefaultParametersOutput - if *v == nil { - sv = &DescribeEngineDefaultParametersOutput{} - } else { - sv = *v - } - - for { - t, done, err := decoder.Token() - if err != nil { - return err - } - if done { - break - } - originalDecoder := decoder - decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) - switch { - case strings.EqualFold("EngineDefaults", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentEngineDefaults(&sv.EngineDefaults, nodeDecoder); err != nil { - return err - } - - default: - // Do nothing and ignore the unexpected tag element - err = decoder.Decoder.Skip() - if err != nil { - return err - } - - } - decoder = originalDecoder - } - *v = sv - return nil -} - -func awsAwsquery_deserializeOpDocumentDescribeEventCategoriesOutput(v **DescribeEventCategoriesOutput, decoder smithyxml.NodeDecoder) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - var sv *DescribeEventCategoriesOutput - if *v == nil { - sv = &DescribeEventCategoriesOutput{} - } else { - sv = *v - } - - for { - t, done, err := decoder.Token() - if err != nil { - return err - } - if done { - break - } - originalDecoder := decoder - decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) - switch { - case strings.EqualFold("EventCategoriesMapList", t.Name.Local): - nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentEventCategoriesMapList(&sv.EventCategoriesMapList, nodeDecoder); err != nil { - return err - } - - default: - // Do nothing and ignore the unexpected tag element - err = decoder.Decoder.Skip() - if err != nil { - return err - } - - } - decoder = originalDecoder - } - *v = sv - return nil -} - -func awsAwsquery_deserializeOpDocumentDescribeEventsOutput(v **DescribeEventsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeEventSubscriptionsOutput(v **DescribeEventSubscriptionsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeEventsOutput + var sv *DescribeEventSubscriptionsOutput if *v == nil { - sv = &DescribeEventsOutput{} + sv = &DescribeEventSubscriptionsOutput{} } else { sv = *v } @@ -52271,9 +53952,9 @@ func awsAwsquery_deserializeOpDocumentDescribeEventsOutput(v **DescribeEventsOut originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("Events", t.Name.Local): + case strings.EqualFold("EventSubscriptionsList", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentEventList(&sv.Events, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentEventSubscriptionsList(&sv.EventSubscriptionsList, nodeDecoder); err != nil { return err } @@ -52304,13 +53985,13 @@ func awsAwsquery_deserializeOpDocumentDescribeEventsOutput(v **DescribeEventsOut return nil } -func awsAwsquery_deserializeOpDocumentDescribeEventSubscriptionsOutput(v **DescribeEventSubscriptionsOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeExportTasksOutput(v **DescribeExportTasksOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeEventSubscriptionsOutput + var sv *DescribeExportTasksOutput if *v == nil { - sv = &DescribeEventSubscriptionsOutput{} + sv = &DescribeExportTasksOutput{} } else { sv = *v } @@ -52326,9 +54007,9 @@ func awsAwsquery_deserializeOpDocumentDescribeEventSubscriptionsOutput(v **Descr originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("EventSubscriptionsList", t.Name.Local): + case strings.EqualFold("ExportTasks", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentEventSubscriptionsList(&sv.EventSubscriptionsList, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentExportTasksList(&sv.ExportTasks, nodeDecoder); err != nil { return err } @@ -52359,13 +54040,13 @@ func awsAwsquery_deserializeOpDocumentDescribeEventSubscriptionsOutput(v **Descr return nil } -func awsAwsquery_deserializeOpDocumentDescribeExportTasksOutput(v **DescribeExportTasksOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeGlobalClustersOutput(v **DescribeGlobalClustersOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeExportTasksOutput + var sv *DescribeGlobalClustersOutput if *v == nil { - sv = &DescribeExportTasksOutput{} + sv = &DescribeGlobalClustersOutput{} } else { sv = *v } @@ -52381,9 +54062,9 @@ func awsAwsquery_deserializeOpDocumentDescribeExportTasksOutput(v **DescribeExpo originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("ExportTasks", t.Name.Local): + case strings.EqualFold("GlobalClusters", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentExportTasksList(&sv.ExportTasks, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentGlobalClusterList(&sv.GlobalClusters, nodeDecoder); err != nil { return err } @@ -52414,13 +54095,13 @@ func awsAwsquery_deserializeOpDocumentDescribeExportTasksOutput(v **DescribeExpo return nil } -func awsAwsquery_deserializeOpDocumentDescribeGlobalClustersOutput(v **DescribeGlobalClustersOutput, decoder smithyxml.NodeDecoder) error { +func awsAwsquery_deserializeOpDocumentDescribeIntegrationsOutput(v **DescribeIntegrationsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } - var sv *DescribeGlobalClustersOutput + var sv *DescribeIntegrationsOutput if *v == nil { - sv = &DescribeGlobalClustersOutput{} + sv = &DescribeIntegrationsOutput{} } else { sv = *v } @@ -52436,9 +54117,9 @@ func awsAwsquery_deserializeOpDocumentDescribeGlobalClustersOutput(v **DescribeG originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { - case strings.EqualFold("GlobalClusters", t.Name.Local): + case strings.EqualFold("Integrations", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) - if err := awsAwsquery_deserializeDocumentGlobalClusterList(&sv.GlobalClusters, nodeDecoder); err != nil { + if err := awsAwsquery_deserializeDocumentIntegrationList(&sv.Integrations, nodeDecoder); err != nil { return err } @@ -53682,6 +55363,22 @@ func awsAwsquery_deserializeOpDocumentModifyCustomDBEngineVersionOutput(v **Modi sv.SupportsGlobalDatabases = ptr.Bool(xtv) } + case strings.EqualFold("SupportsIntegrations", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv, err := strconv.ParseBool(string(val)) + if err != nil { + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) + } + sv.SupportsIntegrations = ptr.Bool(xtv) + } + case strings.EqualFold("SupportsLocalWriteForwarding", t.Name.Local): val, err := decoder.Value() if err != nil { diff --git a/service/rds/generated.json b/service/rds/generated.json index 733a7c8ee85..4cbcc304d77 100644 --- a/service/rds/generated.json +++ b/service/rds/generated.json @@ -44,6 +44,7 @@ "api_op_CreateDBSubnetGroup.go", "api_op_CreateEventSubscription.go", "api_op_CreateGlobalCluster.go", + "api_op_CreateIntegration.go", "api_op_CreateOptionGroup.go", "api_op_DeleteBlueGreenDeployment.go", "api_op_DeleteCustomDBEngineVersion.go", @@ -62,6 +63,7 @@ "api_op_DeleteDBSubnetGroup.go", "api_op_DeleteEventSubscription.go", "api_op_DeleteGlobalCluster.go", + "api_op_DeleteIntegration.go", "api_op_DeleteOptionGroup.go", "api_op_DeregisterDBProxyTargets.go", "api_op_DescribeAccountAttributes.go", @@ -96,6 +98,7 @@ "api_op_DescribeEvents.go", "api_op_DescribeExportTasks.go", "api_op_DescribeGlobalClusters.go", + "api_op_DescribeIntegrations.go", "api_op_DescribeOptionGroupOptions.go", "api_op_DescribeOptionGroups.go", "api_op_DescribeOrderableDBInstanceOptions.go", diff --git a/service/rds/serializers.go b/service/rds/serializers.go index 7ed34d47c1e..a77bcc4cd9b 100644 --- a/service/rds/serializers.go +++ b/service/rds/serializers.go @@ -15,6 +15,7 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" "math" "path" + "sort" ) type awsAwsquery_serializeOpAddRoleToDBCluster struct { @@ -1873,6 +1874,70 @@ func (m *awsAwsquery_serializeOpCreateGlobalCluster) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } +type awsAwsquery_serializeOpCreateIntegration struct { +} + +func (*awsAwsquery_serializeOpCreateIntegration) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsquery_serializeOpCreateIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*CreateIntegrationInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("CreateIntegration") + body.Key("Version").String("2014-10-31") + + if err := awsAwsquery_serializeOpDocumentCreateIntegrationInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsquery_serializeOpCreateOptionGroup struct { } @@ -3025,6 +3090,70 @@ func (m *awsAwsquery_serializeOpDeleteGlobalCluster) HandleSerialize(ctx context return next.HandleSerialize(ctx, in) } +type awsAwsquery_serializeOpDeleteIntegration struct { +} + +func (*awsAwsquery_serializeOpDeleteIntegration) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsquery_serializeOpDeleteIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*DeleteIntegrationInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("DeleteIntegration") + body.Key("Version").String("2014-10-31") + + if err := awsAwsquery_serializeOpDocumentDeleteIntegrationInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsquery_serializeOpDeleteOptionGroup struct { } @@ -5197,6 +5326,70 @@ func (m *awsAwsquery_serializeOpDescribeGlobalClusters) HandleSerialize(ctx cont return next.HandleSerialize(ctx, in) } +type awsAwsquery_serializeOpDescribeIntegrations struct { +} + +func (*awsAwsquery_serializeOpDescribeIntegrations) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsquery_serializeOpDescribeIntegrations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*DescribeIntegrationsInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("DescribeIntegrations") + body.Key("Version").String("2014-10-31") + + if err := awsAwsquery_serializeOpDocumentDescribeIntegrationsInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsquery_serializeOpDescribeOptionGroupOptions struct { } @@ -9313,6 +9506,25 @@ func awsAwsquery_serializeDocumentDBSecurityGroupNameList(v []string, value quer return nil } +func awsAwsquery_serializeDocumentEncryptionContextMap(v map[string]string, value query.Value) error { + if len(v) == 0 { + return nil + } + object := value.Map("key", "value") + + keys := make([]string, 0, len(v)) + for key := range v { + keys = append(keys, key) + } + sort.Strings(keys) + + for _, key := range keys { + om := object.Key(key) + om.String(v[key]) + } + return nil +} + func awsAwsquery_serializeDocumentEngineModeList(v []string, value query.Value) error { array := value.Array("member") @@ -11544,6 +11756,47 @@ func awsAwsquery_serializeOpDocumentCreateGlobalClusterInput(v *CreateGlobalClus return nil } +func awsAwsquery_serializeOpDocumentCreateIntegrationInput(v *CreateIntegrationInput, value query.Value) error { + object := value.Object() + _ = object + + if v.AdditionalEncryptionContext != nil { + objectKey := object.Key("AdditionalEncryptionContext") + if err := awsAwsquery_serializeDocumentEncryptionContextMap(v.AdditionalEncryptionContext, objectKey); err != nil { + return err + } + } + + if v.IntegrationName != nil { + objectKey := object.Key("IntegrationName") + objectKey.String(*v.IntegrationName) + } + + if v.KMSKeyId != nil { + objectKey := object.Key("KMSKeyId") + objectKey.String(*v.KMSKeyId) + } + + if v.SourceArn != nil { + objectKey := object.Key("SourceArn") + objectKey.String(*v.SourceArn) + } + + if v.Tags != nil { + objectKey := object.Key("Tags") + if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil { + return err + } + } + + if v.TargetArn != nil { + objectKey := object.Key("TargetArn") + objectKey.String(*v.TargetArn) + } + + return nil +} + func awsAwsquery_serializeOpDocumentCreateOptionGroupInput(v *CreateOptionGroupInput, value query.Value) error { object := value.Object() _ = object @@ -11827,6 +12080,18 @@ func awsAwsquery_serializeOpDocumentDeleteGlobalClusterInput(v *DeleteGlobalClus return nil } +func awsAwsquery_serializeOpDocumentDeleteIntegrationInput(v *DeleteIntegrationInput, value query.Value) error { + object := value.Object() + _ = object + + if v.IntegrationIdentifier != nil { + objectKey := object.Key("IntegrationIdentifier") + objectKey.String(*v.IntegrationIdentifier) + } + + return nil +} + func awsAwsquery_serializeOpDocumentDeleteOptionGroupInput(v *DeleteOptionGroupInput, value query.Value) error { object := value.Object() _ = object @@ -12919,6 +13184,35 @@ func awsAwsquery_serializeOpDocumentDescribeGlobalClustersInput(v *DescribeGloba return nil } +func awsAwsquery_serializeOpDocumentDescribeIntegrationsInput(v *DescribeIntegrationsInput, value query.Value) error { + object := value.Object() + _ = object + + if v.Filters != nil { + objectKey := object.Key("Filters") + if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil { + return err + } + } + + if v.IntegrationIdentifier != nil { + objectKey := object.Key("IntegrationIdentifier") + objectKey.String(*v.IntegrationIdentifier) + } + + if v.Marker != nil { + objectKey := object.Key("Marker") + objectKey.String(*v.Marker) + } + + if v.MaxRecords != nil { + objectKey := object.Key("MaxRecords") + objectKey.Integer(*v.MaxRecords) + } + + return nil +} + func awsAwsquery_serializeOpDocumentDescribeOptionGroupOptionsInput(v *DescribeOptionGroupOptionsInput, value query.Value) error { object := value.Object() _ = object diff --git a/service/rds/types/enums.go b/service/rds/types/enums.go index f8929f32179..a626e41ef83 100644 --- a/service/rds/types/enums.go +++ b/service/rds/types/enums.go @@ -349,6 +349,34 @@ func (IAMAuthMode) Values() []IAMAuthMode { } } +type IntegrationStatus string + +// Enum values for IntegrationStatus +const ( + IntegrationStatusCreating IntegrationStatus = "creating" + IntegrationStatusActive IntegrationStatus = "active" + IntegrationStatusModifying IntegrationStatus = "modifying" + IntegrationStatusFailed IntegrationStatus = "failed" + IntegrationStatusDeleting IntegrationStatus = "deleting" + IntegrationStatusSyncing IntegrationStatus = "syncing" + IntegrationStatusNeedsAttention IntegrationStatus = "needs_attention" +) + +// Values returns all known values for IntegrationStatus. 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 (IntegrationStatus) Values() []IntegrationStatus { + return []IntegrationStatus{ + "creating", + "active", + "modifying", + "failed", + "deleting", + "syncing", + "needs_attention", + } +} + type LocalWriteForwardingStatus string // Enum values for LocalWriteForwardingStatus diff --git a/service/rds/types/errors.go b/service/rds/types/errors.go index d372f82cea7..f25b9673367 100644 --- a/service/rds/types/errors.go +++ b/service/rds/types/errors.go @@ -2044,6 +2044,113 @@ func (e *InsufficientStorageClusterCapacityFault) ErrorFault() smithy.ErrorFault return smithy.FaultClient } +// The integration you are trying to create already exists. +type IntegrationAlreadyExistsFault struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *IntegrationAlreadyExistsFault) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *IntegrationAlreadyExistsFault) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *IntegrationAlreadyExistsFault) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "IntegrationAlreadyExistsFault" + } + return *e.ErrorCodeOverride +} +func (e *IntegrationAlreadyExistsFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } + +// A conflicting conditional operation is currently in progress against this +// resource. Typically occurs when there are multiple requests being made to the +// same resource at the same time, and these requests conflict with each other. +type IntegrationConflictOperationFault struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *IntegrationConflictOperationFault) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *IntegrationConflictOperationFault) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *IntegrationConflictOperationFault) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "IntegrationConflictOperationFault" + } + return *e.ErrorCodeOverride +} +func (e *IntegrationConflictOperationFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } + +// The specified integration could not be found. +type IntegrationNotFoundFault struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *IntegrationNotFoundFault) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *IntegrationNotFoundFault) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *IntegrationNotFoundFault) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "IntegrationNotFoundFault" + } + return *e.ErrorCodeOverride +} +func (e *IntegrationNotFoundFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } + +// You can't crate any more zero-ETL integrations because the quota has been +// reached. +type IntegrationQuotaExceededFault struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *IntegrationQuotaExceededFault) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *IntegrationQuotaExceededFault) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *IntegrationQuotaExceededFault) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "IntegrationQuotaExceededFault" + } + return *e.ErrorCodeOverride +} +func (e *IntegrationQuotaExceededFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } + // The blue/green deployment can't be switched over or deleted because there is an // invalid configuration in the green environment. type InvalidBlueGreenDeploymentStateFault struct { @@ -2642,6 +2749,33 @@ func (e *InvalidGlobalClusterStateFault) ErrorCode() string { } func (e *InvalidGlobalClusterStateFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +// The integration is in an invalid state and can't perform the requested +// operation. +type InvalidIntegrationStateFault struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *InvalidIntegrationStateFault) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *InvalidIntegrationStateFault) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *InvalidIntegrationStateFault) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "InvalidIntegrationStateFault" + } + return *e.ErrorCodeOverride +} +func (e *InvalidIntegrationStateFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } + // The option group isn't in the available state. type InvalidOptionGroupStateFault struct { Message *string diff --git a/service/rds/types/types.go b/service/rds/types/types.go index 2660f43eccf..12827090a8a 100644 --- a/service/rds/types/types.go +++ b/service/rds/types/types.go @@ -1267,6 +1267,10 @@ type DBEngineVersion struct { // version. SupportsGlobalDatabases *bool + // Indicates whether the DB engine version supports Aurora zero-ETL integrations + // with Amazon Redshift. + SupportsIntegrations *bool + // Indicates whether the DB engine version supports forwarding write operations // from reader DB instances to the writer DB instance in the DB cluster. By // default, write operations aren't allowed on reader DB instances. Valid for: @@ -2769,6 +2773,63 @@ type GlobalClusterMember struct { noSmithyDocumentSerde } +// An Aurora zero-ETL integration with Amazon Redshift. For more information, see +// Working with Amazon Aurora zero-ETL integrations with Amazon Redshift (https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/zero-etl.html) +// in the Amazon Aurora User Guide. +type Integration struct { + + // The encryption context for the integration. For more information, see + // Encryption context (https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) + // in the Amazon Web Services Key Management Service Developer Guide. + AdditionalEncryptionContext map[string]string + + // The time when the integration was created, in Universal Coordinated Time (UTC). + CreateTime *time.Time + + // Any errors associated with the integration. + Errors []IntegrationError + + // The ARN of the integration. + IntegrationArn *string + + // The name of the integration. + IntegrationName *string + + // The Amazon Web Services Key Management System (Amazon Web Services KMS) key + // identifier for the key used to to encrypt the integration. + KMSKeyId *string + + // The Amazon Resource Name (ARN) of the Aurora DB cluster used as the source for + // replication. + SourceArn *string + + // The current status of the integration. + Status IntegrationStatus + + // A list of tags. For more information, see Tagging Amazon RDS Resources (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) + // in the Amazon RDS User Guide. + Tags []Tag + + // The ARN of the Redshift data warehouse used as the target for replication. + TargetArn *string + + noSmithyDocumentSerde +} + +// An error associated with a zero-ETL integration with Amazon Redshift. +type IntegrationError struct { + + // The error code associated with the integration. + // + // This member is required. + ErrorCode *string + + // A message explaining the error. + ErrorMessage *string + + noSmithyDocumentSerde +} + // This data type is used as a response element in the DescribeDBSecurityGroups // action. type IPRange struct { @@ -3877,6 +3938,10 @@ type UpgradeTarget struct { // version. SupportsGlobalDatabases *bool + // Indicates whether the DB engine version supports Aurora zero-ETL integrations + // with Amazon Redshift. + SupportsIntegrations *bool + // Indicates whether the target engine version supports forwarding write // operations from reader DB instances to the writer DB instance in the DB cluster. // By default, write operations aren't allowed on reader DB instances. Valid for: diff --git a/service/rds/validators.go b/service/rds/validators.go index 69224cbc9b1..14ed69a2e99 100644 --- a/service/rds/validators.go +++ b/service/rds/validators.go @@ -570,6 +570,26 @@ func (m *validateOpCreateEventSubscription) HandleInitialize(ctx context.Context return next.HandleInitialize(ctx, in) } +type validateOpCreateIntegration struct { +} + +func (*validateOpCreateIntegration) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateIntegrationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateIntegrationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpCreateOptionGroup struct { } @@ -910,6 +930,26 @@ func (m *validateOpDeleteGlobalCluster) HandleInitialize(ctx context.Context, in return next.HandleInitialize(ctx, in) } +type validateOpDeleteIntegration struct { +} + +func (*validateOpDeleteIntegration) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteIntegrationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteIntegrationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDeleteOptionGroup struct { } @@ -1570,6 +1610,26 @@ func (m *validateOpDescribeGlobalClusters) HandleInitialize(ctx context.Context, return next.HandleInitialize(ctx, in) } +type validateOpDescribeIntegrations struct { +} + +func (*validateOpDescribeIntegrations) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDescribeIntegrations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DescribeIntegrationsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDescribeIntegrationsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDescribeOptionGroupOptions struct { } @@ -2862,6 +2922,10 @@ func addOpCreateEventSubscriptionValidationMiddleware(stack *middleware.Stack) e return stack.Initialize.Add(&validateOpCreateEventSubscription{}, middleware.After) } +func addOpCreateIntegrationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateIntegration{}, middleware.After) +} + func addOpCreateOptionGroupValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateOptionGroup{}, middleware.After) } @@ -2930,6 +2994,10 @@ func addOpDeleteGlobalClusterValidationMiddleware(stack *middleware.Stack) error return stack.Initialize.Add(&validateOpDeleteGlobalCluster{}, middleware.After) } +func addOpDeleteIntegrationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteIntegration{}, middleware.After) +} + func addOpDeleteOptionGroupValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteOptionGroup{}, middleware.After) } @@ -3062,6 +3130,10 @@ func addOpDescribeGlobalClustersValidationMiddleware(stack *middleware.Stack) er return stack.Initialize.Add(&validateOpDescribeGlobalClusters{}, middleware.After) } +func addOpDescribeIntegrationsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDescribeIntegrations{}, middleware.After) +} + func addOpDescribeOptionGroupOptionsValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDescribeOptionGroupOptions{}, middleware.After) } @@ -3902,6 +3974,27 @@ func validateOpCreateEventSubscriptionInput(v *CreateEventSubscriptionInput) err } } +func validateOpCreateIntegrationInput(v *CreateIntegrationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CreateIntegrationInput"} + if v.SourceArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("SourceArn")) + } + if v.TargetArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("TargetArn")) + } + if v.IntegrationName == nil { + invalidParams.Add(smithy.NewErrParamRequired("IntegrationName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpCreateOptionGroupInput(v *CreateOptionGroupInput) error { if v == nil { return nil @@ -4169,6 +4262,21 @@ func validateOpDeleteGlobalClusterInput(v *DeleteGlobalClusterInput) error { } } +func validateOpDeleteIntegrationInput(v *DeleteIntegrationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DeleteIntegrationInput"} + if v.IntegrationIdentifier == nil { + invalidParams.Add(smithy.NewErrParamRequired("IntegrationIdentifier")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpDeleteOptionGroupInput(v *DeleteOptionGroupInput) error { if v == nil { return nil @@ -4746,6 +4854,23 @@ func validateOpDescribeGlobalClustersInput(v *DescribeGlobalClustersInput) error } } +func validateOpDescribeIntegrationsInput(v *DescribeIntegrationsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DescribeIntegrationsInput"} + if v.Filters != nil { + if err := validateFilterList(v.Filters); err != nil { + invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpDescribeOptionGroupOptionsInput(v *DescribeOptionGroupOptionsInput) error { if v == nil { return nil diff --git a/service/redshiftserverless/api_op_CreateCustomDomainAssociation.go b/service/redshiftserverless/api_op_CreateCustomDomainAssociation.go new file mode 100644 index 00000000000..5d91757f6a4 --- /dev/null +++ b/service/redshiftserverless/api_op_CreateCustomDomainAssociation.go @@ -0,0 +1,280 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package redshiftserverless + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + internalauth "github.com/aws/aws-sdk-go-v2/internal/auth" + smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" + "time" +) + +// Creates a custom domain association for Amazon Redshift Serverless. +func (c *Client) CreateCustomDomainAssociation(ctx context.Context, params *CreateCustomDomainAssociationInput, optFns ...func(*Options)) (*CreateCustomDomainAssociationOutput, error) { + if params == nil { + params = &CreateCustomDomainAssociationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateCustomDomainAssociation", params, optFns, c.addOperationCreateCustomDomainAssociationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateCustomDomainAssociationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateCustomDomainAssociationInput struct { + + // The custom domain name’s certificate Amazon resource name (ARN). + // + // This member is required. + CustomDomainCertificateArn *string + + // The custom domain name to associate with the workgroup. + // + // This member is required. + CustomDomainName *string + + // The name of the workgroup associated with the database. + // + // This member is required. + WorkgroupName *string + + noSmithyDocumentSerde +} + +type CreateCustomDomainAssociationOutput struct { + + // The custom domain name’s certificate Amazon resource name (ARN). + CustomDomainCertificateArn *string + + // The expiration time for the certificate. + CustomDomainCertificateExpiryTime *time.Time + + // The custom domain name to associate with the workgroup. + CustomDomainName *string + + // The name of the workgroup associated with the database. + WorkgroupName *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationCreateCustomDomainAssociationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack, 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 = addCreateCustomDomainAssociationResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addOpCreateCustomDomainAssociationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateCustomDomainAssociation(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opCreateCustomDomainAssociation(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "redshift-serverless", + OperationName: "CreateCustomDomainAssociation", + } +} + +type opCreateCustomDomainAssociationResolveEndpointMiddleware struct { + EndpointResolver EndpointResolverV2 + BuiltInResolver builtInParameterResolver +} + +func (*opCreateCustomDomainAssociationResolveEndpointMiddleware) ID() string { + return "ResolveEndpointV2" +} + +func (m *opCreateCustomDomainAssociationResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if awsmiddleware.GetRequiresLegacyEndpoints(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + if m.EndpointResolver == nil { + return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil") + } + + params := EndpointParameters{} + + m.BuiltInResolver.ResolveBuiltIns(¶ms) + + var resolvedEndpoint smithyendpoints.Endpoint + resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params) + if err != nil { + return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err) + } + + req.URL = &resolvedEndpoint.URI + + for k := range resolvedEndpoint.Headers { + req.Header.Set( + k, + resolvedEndpoint.Headers.Get(k), + ) + } + + authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties) + if err != nil { + var nfe *internalauth.NoAuthenticationSchemesFoundError + if errors.As(err, &nfe) { + // if no auth scheme is found, default to sigv4 + signingName := "redshift-serverless" + signingRegion := m.BuiltInResolver.(*builtInResolver).Region + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + + } + var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError + if errors.As(err, &ue) { + return out, metadata, fmt.Errorf( + "This operation requests signer version(s) %v but the client only supports %v", + ue.UnsupportedSchemes, + internalauth.SupportedSchemes, + ) + } + } + + for _, authScheme := range authSchemes { + switch authScheme.(type) { + case *internalauth.AuthenticationSchemeV4: + v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4) + var signingName, signingRegion string + if v4Scheme.SigningName == nil { + signingName = "redshift-serverless" + } else { + signingName = *v4Scheme.SigningName + } + if v4Scheme.SigningRegion == nil { + signingRegion = m.BuiltInResolver.(*builtInResolver).Region + } else { + signingRegion = *v4Scheme.SigningRegion + } + if v4Scheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + break + case *internalauth.AuthenticationSchemeV4A: + v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A) + if v4aScheme.SigningName == nil { + v4aScheme.SigningName = aws.String("redshift-serverless") + } + if v4aScheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName) + ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0]) + break + case *internalauth.AuthenticationSchemeNone: + break + } + } + + return next.HandleSerialize(ctx, in) +} + +func addCreateCustomDomainAssociationResolveEndpointMiddleware(stack *middleware.Stack, options Options) error { + return stack.Serialize.Insert(&opCreateCustomDomainAssociationResolveEndpointMiddleware{ + EndpointResolver: options.EndpointResolverV2, + BuiltInResolver: &builtInResolver{ + Region: options.Region, + UseDualStack: options.EndpointOptions.UseDualStackEndpoint, + UseFIPS: options.EndpointOptions.UseFIPSEndpoint, + Endpoint: options.BaseEndpoint, + }, + }, "ResolveEndpoint", middleware.After) +} diff --git a/service/redshiftserverless/api_op_DeleteCustomDomainAssociation.go b/service/redshiftserverless/api_op_DeleteCustomDomainAssociation.go new file mode 100644 index 00000000000..ecfda6d46aa --- /dev/null +++ b/service/redshiftserverless/api_op_DeleteCustomDomainAssociation.go @@ -0,0 +1,261 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package redshiftserverless + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + internalauth "github.com/aws/aws-sdk-go-v2/internal/auth" + smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Deletes a custom domain association for Amazon Redshift Serverless. +func (c *Client) DeleteCustomDomainAssociation(ctx context.Context, params *DeleteCustomDomainAssociationInput, optFns ...func(*Options)) (*DeleteCustomDomainAssociationOutput, error) { + if params == nil { + params = &DeleteCustomDomainAssociationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteCustomDomainAssociation", params, optFns, c.addOperationDeleteCustomDomainAssociationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteCustomDomainAssociationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteCustomDomainAssociationInput struct { + + // The custom domain name associated with the workgroup. + // + // This member is required. + CustomDomainName *string + + // The name of the workgroup associated with the database. + // + // This member is required. + WorkgroupName *string + + noSmithyDocumentSerde +} + +type DeleteCustomDomainAssociationOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDeleteCustomDomainAssociationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack, 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 = addDeleteCustomDomainAssociationResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addOpDeleteCustomDomainAssociationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteCustomDomainAssociation(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opDeleteCustomDomainAssociation(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "redshift-serverless", + OperationName: "DeleteCustomDomainAssociation", + } +} + +type opDeleteCustomDomainAssociationResolveEndpointMiddleware struct { + EndpointResolver EndpointResolverV2 + BuiltInResolver builtInParameterResolver +} + +func (*opDeleteCustomDomainAssociationResolveEndpointMiddleware) ID() string { + return "ResolveEndpointV2" +} + +func (m *opDeleteCustomDomainAssociationResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if awsmiddleware.GetRequiresLegacyEndpoints(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + if m.EndpointResolver == nil { + return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil") + } + + params := EndpointParameters{} + + m.BuiltInResolver.ResolveBuiltIns(¶ms) + + var resolvedEndpoint smithyendpoints.Endpoint + resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params) + if err != nil { + return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err) + } + + req.URL = &resolvedEndpoint.URI + + for k := range resolvedEndpoint.Headers { + req.Header.Set( + k, + resolvedEndpoint.Headers.Get(k), + ) + } + + authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties) + if err != nil { + var nfe *internalauth.NoAuthenticationSchemesFoundError + if errors.As(err, &nfe) { + // if no auth scheme is found, default to sigv4 + signingName := "redshift-serverless" + signingRegion := m.BuiltInResolver.(*builtInResolver).Region + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + + } + var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError + if errors.As(err, &ue) { + return out, metadata, fmt.Errorf( + "This operation requests signer version(s) %v but the client only supports %v", + ue.UnsupportedSchemes, + internalauth.SupportedSchemes, + ) + } + } + + for _, authScheme := range authSchemes { + switch authScheme.(type) { + case *internalauth.AuthenticationSchemeV4: + v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4) + var signingName, signingRegion string + if v4Scheme.SigningName == nil { + signingName = "redshift-serverless" + } else { + signingName = *v4Scheme.SigningName + } + if v4Scheme.SigningRegion == nil { + signingRegion = m.BuiltInResolver.(*builtInResolver).Region + } else { + signingRegion = *v4Scheme.SigningRegion + } + if v4Scheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + break + case *internalauth.AuthenticationSchemeV4A: + v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A) + if v4aScheme.SigningName == nil { + v4aScheme.SigningName = aws.String("redshift-serverless") + } + if v4aScheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName) + ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0]) + break + case *internalauth.AuthenticationSchemeNone: + break + } + } + + return next.HandleSerialize(ctx, in) +} + +func addDeleteCustomDomainAssociationResolveEndpointMiddleware(stack *middleware.Stack, options Options) error { + return stack.Serialize.Insert(&opDeleteCustomDomainAssociationResolveEndpointMiddleware{ + EndpointResolver: options.EndpointResolverV2, + BuiltInResolver: &builtInResolver{ + Region: options.Region, + UseDualStack: options.EndpointOptions.UseDualStackEndpoint, + UseFIPS: options.EndpointOptions.UseFIPSEndpoint, + Endpoint: options.BaseEndpoint, + }, + }, "ResolveEndpoint", middleware.After) +} diff --git a/service/redshiftserverless/api_op_GetCredentials.go b/service/redshiftserverless/api_op_GetCredentials.go index 5127bea934a..4473d7bd0e3 100644 --- a/service/redshiftserverless/api_op_GetCredentials.go +++ b/service/redshiftserverless/api_op_GetCredentials.go @@ -41,10 +41,9 @@ func (c *Client) GetCredentials(ctx context.Context, params *GetCredentialsInput type GetCredentialsInput struct { - // The name of the workgroup associated with the database. - // - // This member is required. - WorkgroupName *string + // The custom domain name associated with the workgroup. The custom domain name or + // the workgroup name must be included in the request. + CustomDomainName *string // The name of the database to get temporary authorization to log on to. // Constraints: @@ -62,6 +61,9 @@ type GetCredentialsInput struct { // minimum is 900 seconds, and the maximum is 3600 seconds. DurationSeconds *int32 + // The name of the workgroup associated with the database. + WorkgroupName *string + noSmithyDocumentSerde } @@ -140,9 +142,6 @@ func (c *Client) addOperationGetCredentialsMiddlewares(stack *middleware.Stack, if err = addGetCredentialsResolveEndpointMiddleware(stack, options); err != nil { return err } - if err = addOpGetCredentialsValidationMiddleware(stack); err != nil { - return err - } if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetCredentials(options.Region), middleware.Before); err != nil { return err } diff --git a/service/redshiftserverless/api_op_GetCustomDomainAssociation.go b/service/redshiftserverless/api_op_GetCustomDomainAssociation.go new file mode 100644 index 00000000000..76f469323d4 --- /dev/null +++ b/service/redshiftserverless/api_op_GetCustomDomainAssociation.go @@ -0,0 +1,275 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package redshiftserverless + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + internalauth "github.com/aws/aws-sdk-go-v2/internal/auth" + smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" + "time" +) + +// Gets information about a specific custom domain association. +func (c *Client) GetCustomDomainAssociation(ctx context.Context, params *GetCustomDomainAssociationInput, optFns ...func(*Options)) (*GetCustomDomainAssociationOutput, error) { + if params == nil { + params = &GetCustomDomainAssociationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetCustomDomainAssociation", params, optFns, c.addOperationGetCustomDomainAssociationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetCustomDomainAssociationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetCustomDomainAssociationInput struct { + + // The custom domain name associated with the workgroup. + // + // This member is required. + CustomDomainName *string + + // The name of the workgroup associated with the database. + // + // This member is required. + WorkgroupName *string + + noSmithyDocumentSerde +} + +type GetCustomDomainAssociationOutput struct { + + // The custom domain name’s certificate Amazon resource name (ARN). + CustomDomainCertificateArn *string + + // The expiration time for the certificate. + CustomDomainCertificateExpiryTime *time.Time + + // The custom domain name associated with the workgroup. + CustomDomainName *string + + // The name of the workgroup associated with the database. + WorkgroupName *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationGetCustomDomainAssociationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack, 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 = addGetCustomDomainAssociationResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addOpGetCustomDomainAssociationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetCustomDomainAssociation(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opGetCustomDomainAssociation(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "redshift-serverless", + OperationName: "GetCustomDomainAssociation", + } +} + +type opGetCustomDomainAssociationResolveEndpointMiddleware struct { + EndpointResolver EndpointResolverV2 + BuiltInResolver builtInParameterResolver +} + +func (*opGetCustomDomainAssociationResolveEndpointMiddleware) ID() string { + return "ResolveEndpointV2" +} + +func (m *opGetCustomDomainAssociationResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if awsmiddleware.GetRequiresLegacyEndpoints(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + if m.EndpointResolver == nil { + return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil") + } + + params := EndpointParameters{} + + m.BuiltInResolver.ResolveBuiltIns(¶ms) + + var resolvedEndpoint smithyendpoints.Endpoint + resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params) + if err != nil { + return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err) + } + + req.URL = &resolvedEndpoint.URI + + for k := range resolvedEndpoint.Headers { + req.Header.Set( + k, + resolvedEndpoint.Headers.Get(k), + ) + } + + authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties) + if err != nil { + var nfe *internalauth.NoAuthenticationSchemesFoundError + if errors.As(err, &nfe) { + // if no auth scheme is found, default to sigv4 + signingName := "redshift-serverless" + signingRegion := m.BuiltInResolver.(*builtInResolver).Region + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + + } + var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError + if errors.As(err, &ue) { + return out, metadata, fmt.Errorf( + "This operation requests signer version(s) %v but the client only supports %v", + ue.UnsupportedSchemes, + internalauth.SupportedSchemes, + ) + } + } + + for _, authScheme := range authSchemes { + switch authScheme.(type) { + case *internalauth.AuthenticationSchemeV4: + v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4) + var signingName, signingRegion string + if v4Scheme.SigningName == nil { + signingName = "redshift-serverless" + } else { + signingName = *v4Scheme.SigningName + } + if v4Scheme.SigningRegion == nil { + signingRegion = m.BuiltInResolver.(*builtInResolver).Region + } else { + signingRegion = *v4Scheme.SigningRegion + } + if v4Scheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + break + case *internalauth.AuthenticationSchemeV4A: + v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A) + if v4aScheme.SigningName == nil { + v4aScheme.SigningName = aws.String("redshift-serverless") + } + if v4aScheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName) + ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0]) + break + case *internalauth.AuthenticationSchemeNone: + break + } + } + + return next.HandleSerialize(ctx, in) +} + +func addGetCustomDomainAssociationResolveEndpointMiddleware(stack *middleware.Stack, options Options) error { + return stack.Serialize.Insert(&opGetCustomDomainAssociationResolveEndpointMiddleware{ + EndpointResolver: options.EndpointResolverV2, + BuiltInResolver: &builtInResolver{ + Region: options.Region, + UseDualStack: options.EndpointOptions.UseDualStackEndpoint, + UseFIPS: options.EndpointOptions.UseFIPSEndpoint, + Endpoint: options.BaseEndpoint, + }, + }, "ResolveEndpoint", middleware.After) +} diff --git a/service/redshiftserverless/api_op_ListCustomDomainAssociations.go b/service/redshiftserverless/api_op_ListCustomDomainAssociations.go new file mode 100644 index 00000000000..c9c3d0c095f --- /dev/null +++ b/service/redshiftserverless/api_op_ListCustomDomainAssociations.go @@ -0,0 +1,367 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package redshiftserverless + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + internalauth "github.com/aws/aws-sdk-go-v2/internal/auth" + "github.com/aws/aws-sdk-go-v2/service/redshiftserverless/types" + smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Lists custom domain associations for Amazon Redshift Serverless. +func (c *Client) ListCustomDomainAssociations(ctx context.Context, params *ListCustomDomainAssociationsInput, optFns ...func(*Options)) (*ListCustomDomainAssociationsOutput, error) { + if params == nil { + params = &ListCustomDomainAssociationsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ListCustomDomainAssociations", params, optFns, c.addOperationListCustomDomainAssociationsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ListCustomDomainAssociationsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ListCustomDomainAssociationsInput struct { + + // The custom domain name’s certificate Amazon resource name (ARN). + CustomDomainCertificateArn *string + + // The custom domain name associated with the workgroup. + CustomDomainName *string + + // An optional parameter that specifies the maximum number of results to return. + // You can use nextToken to display the next page of results. + MaxResults *int32 + + // When nextToken is returned, there are more results available. The value of + // nextToken is a unique pagination token for each page. Make the call again using + // the returned token to retrieve the next page. + NextToken *string + + noSmithyDocumentSerde +} + +type ListCustomDomainAssociationsOutput struct { + + // A list of Association objects. + Associations []types.Association + + // When nextToken is returned, there are more results available. The value of + // nextToken is a unique pagination token for each page. Make the call again using + // the returned token to retrieve the next page. + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationListCustomDomainAssociationsMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpListCustomDomainAssociations{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListCustomDomainAssociations{}, middleware.After) + if err != nil { + return err + } + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack, 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 = addListCustomDomainAssociationsResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListCustomDomainAssociations(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + return nil +} + +// ListCustomDomainAssociationsAPIClient is a client that implements the +// ListCustomDomainAssociations operation. +type ListCustomDomainAssociationsAPIClient interface { + ListCustomDomainAssociations(context.Context, *ListCustomDomainAssociationsInput, ...func(*Options)) (*ListCustomDomainAssociationsOutput, error) +} + +var _ ListCustomDomainAssociationsAPIClient = (*Client)(nil) + +// ListCustomDomainAssociationsPaginatorOptions is the paginator options for +// ListCustomDomainAssociations +type ListCustomDomainAssociationsPaginatorOptions struct { + // An optional parameter that specifies the maximum number of results to return. + // You can use nextToken to display the next page of results. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// ListCustomDomainAssociationsPaginator is a paginator for +// ListCustomDomainAssociations +type ListCustomDomainAssociationsPaginator struct { + options ListCustomDomainAssociationsPaginatorOptions + client ListCustomDomainAssociationsAPIClient + params *ListCustomDomainAssociationsInput + nextToken *string + firstPage bool +} + +// NewListCustomDomainAssociationsPaginator returns a new +// ListCustomDomainAssociationsPaginator +func NewListCustomDomainAssociationsPaginator(client ListCustomDomainAssociationsAPIClient, params *ListCustomDomainAssociationsInput, optFns ...func(*ListCustomDomainAssociationsPaginatorOptions)) *ListCustomDomainAssociationsPaginator { + if params == nil { + params = &ListCustomDomainAssociationsInput{} + } + + options := ListCustomDomainAssociationsPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &ListCustomDomainAssociationsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *ListCustomDomainAssociationsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next ListCustomDomainAssociations page. +func (p *ListCustomDomainAssociationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListCustomDomainAssociationsOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.NextToken = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxResults = limit + + result, err := p.client.ListCustomDomainAssociations(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.NextToken + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +func newServiceMetadataMiddleware_opListCustomDomainAssociations(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "redshift-serverless", + OperationName: "ListCustomDomainAssociations", + } +} + +type opListCustomDomainAssociationsResolveEndpointMiddleware struct { + EndpointResolver EndpointResolverV2 + BuiltInResolver builtInParameterResolver +} + +func (*opListCustomDomainAssociationsResolveEndpointMiddleware) ID() string { + return "ResolveEndpointV2" +} + +func (m *opListCustomDomainAssociationsResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if awsmiddleware.GetRequiresLegacyEndpoints(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + if m.EndpointResolver == nil { + return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil") + } + + params := EndpointParameters{} + + m.BuiltInResolver.ResolveBuiltIns(¶ms) + + var resolvedEndpoint smithyendpoints.Endpoint + resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params) + if err != nil { + return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err) + } + + req.URL = &resolvedEndpoint.URI + + for k := range resolvedEndpoint.Headers { + req.Header.Set( + k, + resolvedEndpoint.Headers.Get(k), + ) + } + + authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties) + if err != nil { + var nfe *internalauth.NoAuthenticationSchemesFoundError + if errors.As(err, &nfe) { + // if no auth scheme is found, default to sigv4 + signingName := "redshift-serverless" + signingRegion := m.BuiltInResolver.(*builtInResolver).Region + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + + } + var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError + if errors.As(err, &ue) { + return out, metadata, fmt.Errorf( + "This operation requests signer version(s) %v but the client only supports %v", + ue.UnsupportedSchemes, + internalauth.SupportedSchemes, + ) + } + } + + for _, authScheme := range authSchemes { + switch authScheme.(type) { + case *internalauth.AuthenticationSchemeV4: + v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4) + var signingName, signingRegion string + if v4Scheme.SigningName == nil { + signingName = "redshift-serverless" + } else { + signingName = *v4Scheme.SigningName + } + if v4Scheme.SigningRegion == nil { + signingRegion = m.BuiltInResolver.(*builtInResolver).Region + } else { + signingRegion = *v4Scheme.SigningRegion + } + if v4Scheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + break + case *internalauth.AuthenticationSchemeV4A: + v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A) + if v4aScheme.SigningName == nil { + v4aScheme.SigningName = aws.String("redshift-serverless") + } + if v4aScheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName) + ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0]) + break + case *internalauth.AuthenticationSchemeNone: + break + } + } + + return next.HandleSerialize(ctx, in) +} + +func addListCustomDomainAssociationsResolveEndpointMiddleware(stack *middleware.Stack, options Options) error { + return stack.Serialize.Insert(&opListCustomDomainAssociationsResolveEndpointMiddleware{ + EndpointResolver: options.EndpointResolverV2, + BuiltInResolver: &builtInResolver{ + Region: options.Region, + UseDualStack: options.EndpointOptions.UseDualStackEndpoint, + UseFIPS: options.EndpointOptions.UseFIPSEndpoint, + Endpoint: options.BaseEndpoint, + }, + }, "ResolveEndpoint", middleware.After) +} diff --git a/service/redshiftserverless/api_op_UpdateCustomDomainAssociation.go b/service/redshiftserverless/api_op_UpdateCustomDomainAssociation.go new file mode 100644 index 00000000000..946e3d5b7cb --- /dev/null +++ b/service/redshiftserverless/api_op_UpdateCustomDomainAssociation.go @@ -0,0 +1,282 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package redshiftserverless + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + internalauth "github.com/aws/aws-sdk-go-v2/internal/auth" + smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" + "time" +) + +// Updates an Amazon Redshift Serverless certificate associated with a custom +// domain. +func (c *Client) UpdateCustomDomainAssociation(ctx context.Context, params *UpdateCustomDomainAssociationInput, optFns ...func(*Options)) (*UpdateCustomDomainAssociationOutput, error) { + if params == nil { + params = &UpdateCustomDomainAssociationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "UpdateCustomDomainAssociation", params, optFns, c.addOperationUpdateCustomDomainAssociationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*UpdateCustomDomainAssociationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type UpdateCustomDomainAssociationInput struct { + + // The custom domain name’s certificate Amazon resource name (ARN). This is + // optional. + // + // This member is required. + CustomDomainCertificateArn *string + + // The custom domain name associated with the workgroup. + // + // This member is required. + CustomDomainName *string + + // The name of the workgroup associated with the database. + // + // This member is required. + WorkgroupName *string + + noSmithyDocumentSerde +} + +type UpdateCustomDomainAssociationOutput struct { + + // The custom domain name’s certificate Amazon resource name (ARN). + CustomDomainCertificateArn *string + + // The expiration time for the certificate. + CustomDomainCertificateExpiryTime *time.Time + + // The custom domain name associated with the workgroup. + CustomDomainName *string + + // The name of the workgroup associated with the database. + WorkgroupName *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationUpdateCustomDomainAssociationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateCustomDomainAssociation{}, middleware.After) + if err != nil { + return err + } + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack, 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 = addUpdateCustomDomainAssociationResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addOpUpdateCustomDomainAssociationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateCustomDomainAssociation(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opUpdateCustomDomainAssociation(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "redshift-serverless", + OperationName: "UpdateCustomDomainAssociation", + } +} + +type opUpdateCustomDomainAssociationResolveEndpointMiddleware struct { + EndpointResolver EndpointResolverV2 + BuiltInResolver builtInParameterResolver +} + +func (*opUpdateCustomDomainAssociationResolveEndpointMiddleware) ID() string { + return "ResolveEndpointV2" +} + +func (m *opUpdateCustomDomainAssociationResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if awsmiddleware.GetRequiresLegacyEndpoints(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + if m.EndpointResolver == nil { + return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil") + } + + params := EndpointParameters{} + + m.BuiltInResolver.ResolveBuiltIns(¶ms) + + var resolvedEndpoint smithyendpoints.Endpoint + resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params) + if err != nil { + return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err) + } + + req.URL = &resolvedEndpoint.URI + + for k := range resolvedEndpoint.Headers { + req.Header.Set( + k, + resolvedEndpoint.Headers.Get(k), + ) + } + + authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties) + if err != nil { + var nfe *internalauth.NoAuthenticationSchemesFoundError + if errors.As(err, &nfe) { + // if no auth scheme is found, default to sigv4 + signingName := "redshift-serverless" + signingRegion := m.BuiltInResolver.(*builtInResolver).Region + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + + } + var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError + if errors.As(err, &ue) { + return out, metadata, fmt.Errorf( + "This operation requests signer version(s) %v but the client only supports %v", + ue.UnsupportedSchemes, + internalauth.SupportedSchemes, + ) + } + } + + for _, authScheme := range authSchemes { + switch authScheme.(type) { + case *internalauth.AuthenticationSchemeV4: + v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4) + var signingName, signingRegion string + if v4Scheme.SigningName == nil { + signingName = "redshift-serverless" + } else { + signingName = *v4Scheme.SigningName + } + if v4Scheme.SigningRegion == nil { + signingRegion = m.BuiltInResolver.(*builtInResolver).Region + } else { + signingRegion = *v4Scheme.SigningRegion + } + if v4Scheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, signingName) + ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion) + break + case *internalauth.AuthenticationSchemeV4A: + v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A) + if v4aScheme.SigningName == nil { + v4aScheme.SigningName = aws.String("redshift-serverless") + } + if v4aScheme.DisableDoubleEncoding != nil { + // The signer sets an equivalent value at client initialization time. + // Setting this context value will cause the signer to extract it + // and override the value set at client initialization time. + ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding) + } + ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName) + ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0]) + break + case *internalauth.AuthenticationSchemeNone: + break + } + } + + return next.HandleSerialize(ctx, in) +} + +func addUpdateCustomDomainAssociationResolveEndpointMiddleware(stack *middleware.Stack, options Options) error { + return stack.Serialize.Insert(&opUpdateCustomDomainAssociationResolveEndpointMiddleware{ + EndpointResolver: options.EndpointResolverV2, + BuiltInResolver: &builtInResolver{ + Region: options.Region, + UseDualStack: options.EndpointOptions.UseDualStackEndpoint, + UseFIPS: options.EndpointOptions.UseFIPSEndpoint, + Endpoint: options.BaseEndpoint, + }, + }, "ResolveEndpoint", middleware.After) +} diff --git a/service/redshiftserverless/deserializers.go b/service/redshiftserverless/deserializers.go index f7b9fb3b5f9..7357e46227d 100644 --- a/service/redshiftserverless/deserializers.go +++ b/service/redshiftserverless/deserializers.go @@ -146,14 +146,14 @@ func awsAwsjson11_deserializeOpErrorConvertRecoveryPointToSnapshot(response *smi } } -type awsAwsjson11_deserializeOpCreateEndpointAccess struct { +type awsAwsjson11_deserializeOpCreateCustomDomainAssociation struct { } -func (*awsAwsjson11_deserializeOpCreateEndpointAccess) ID() string { +func (*awsAwsjson11_deserializeOpCreateCustomDomainAssociation) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpCreateEndpointAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCreateCustomDomainAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -167,9 +167,9 @@ func (m *awsAwsjson11_deserializeOpCreateEndpointAccess) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorCreateEndpointAccess(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCreateCustomDomainAssociation(response, &metadata) } - output := &CreateEndpointAccessOutput{} + output := &CreateCustomDomainAssociationOutput{} out.Result = output var buff [1024]byte @@ -189,7 +189,7 @@ func (m *awsAwsjson11_deserializeOpCreateEndpointAccess) HandleDeserialize(ctx c return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentCreateEndpointAccessOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentCreateCustomDomainAssociationOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -203,7 +203,7 @@ func (m *awsAwsjson11_deserializeOpCreateEndpointAccess) HandleDeserialize(ctx c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorCreateEndpointAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCreateCustomDomainAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -256,8 +256,8 @@ func awsAwsjson11_deserializeOpErrorCreateEndpointAccess(response *smithyhttp.Re case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) case strings.EqualFold("ValidationException", errorCode): return awsAwsjson11_deserializeErrorValidationException(response, errorBody) @@ -272,14 +272,14 @@ func awsAwsjson11_deserializeOpErrorCreateEndpointAccess(response *smithyhttp.Re } } -type awsAwsjson11_deserializeOpCreateNamespace struct { +type awsAwsjson11_deserializeOpCreateEndpointAccess struct { } -func (*awsAwsjson11_deserializeOpCreateNamespace) ID() string { +func (*awsAwsjson11_deserializeOpCreateEndpointAccess) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpCreateNamespace) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCreateEndpointAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -293,9 +293,9 @@ func (m *awsAwsjson11_deserializeOpCreateNamespace) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorCreateNamespace(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCreateEndpointAccess(response, &metadata) } - output := &CreateNamespaceOutput{} + output := &CreateEndpointAccessOutput{} out.Result = output var buff [1024]byte @@ -315,7 +315,7 @@ func (m *awsAwsjson11_deserializeOpCreateNamespace) HandleDeserialize(ctx contex return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentCreateNamespaceOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentCreateEndpointAccessOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -329,7 +329,7 @@ func (m *awsAwsjson11_deserializeOpCreateNamespace) HandleDeserialize(ctx contex return out, metadata, err } -func awsAwsjson11_deserializeOpErrorCreateNamespace(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCreateEndpointAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -370,14 +370,20 @@ func awsAwsjson11_deserializeOpErrorCreateNamespace(response *smithyhttp.Respons } switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): return awsAwsjson11_deserializeErrorConflictException(response, errorBody) case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("TooManyTagsException", errorCode): - return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) case strings.EqualFold("ValidationException", errorCode): return awsAwsjson11_deserializeErrorValidationException(response, errorBody) @@ -392,14 +398,14 @@ func awsAwsjson11_deserializeOpErrorCreateNamespace(response *smithyhttp.Respons } } -type awsAwsjson11_deserializeOpCreateSnapshot struct { +type awsAwsjson11_deserializeOpCreateNamespace struct { } -func (*awsAwsjson11_deserializeOpCreateSnapshot) ID() string { +func (*awsAwsjson11_deserializeOpCreateNamespace) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpCreateSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCreateNamespace) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -413,9 +419,9 @@ func (m *awsAwsjson11_deserializeOpCreateSnapshot) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorCreateSnapshot(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCreateNamespace(response, &metadata) } - output := &CreateSnapshotOutput{} + output := &CreateNamespaceOutput{} out.Result = output var buff [1024]byte @@ -435,7 +441,7 @@ func (m *awsAwsjson11_deserializeOpCreateSnapshot) HandleDeserialize(ctx context return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentCreateSnapshotOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentCreateNamespaceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -449,7 +455,7 @@ func (m *awsAwsjson11_deserializeOpCreateSnapshot) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsjson11_deserializeOpErrorCreateSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCreateNamespace(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -496,12 +502,6 @@ func awsAwsjson11_deserializeOpErrorCreateSnapshot(response *smithyhttp.Response case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - - case strings.EqualFold("ServiceQuotaExceededException", errorCode): - return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) - case strings.EqualFold("TooManyTagsException", errorCode): return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) @@ -518,14 +518,14 @@ func awsAwsjson11_deserializeOpErrorCreateSnapshot(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpCreateUsageLimit struct { +type awsAwsjson11_deserializeOpCreateSnapshot struct { } -func (*awsAwsjson11_deserializeOpCreateUsageLimit) ID() string { +func (*awsAwsjson11_deserializeOpCreateSnapshot) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpCreateUsageLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCreateSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -539,9 +539,9 @@ func (m *awsAwsjson11_deserializeOpCreateUsageLimit) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorCreateUsageLimit(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCreateSnapshot(response, &metadata) } - output := &CreateUsageLimitOutput{} + output := &CreateSnapshotOutput{} out.Result = output var buff [1024]byte @@ -561,7 +561,7 @@ func (m *awsAwsjson11_deserializeOpCreateUsageLimit) HandleDeserialize(ctx conte return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentCreateUsageLimitOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentCreateSnapshotOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -575,7 +575,7 @@ func (m *awsAwsjson11_deserializeOpCreateUsageLimit) HandleDeserialize(ctx conte return out, metadata, err } -func awsAwsjson11_deserializeOpErrorCreateUsageLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCreateSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -628,6 +628,9 @@ func awsAwsjson11_deserializeOpErrorCreateUsageLimit(response *smithyhttp.Respon case strings.EqualFold("ServiceQuotaExceededException", errorCode): return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) + case strings.EqualFold("TooManyTagsException", errorCode): + return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) + case strings.EqualFold("ValidationException", errorCode): return awsAwsjson11_deserializeErrorValidationException(response, errorBody) @@ -641,14 +644,14 @@ func awsAwsjson11_deserializeOpErrorCreateUsageLimit(response *smithyhttp.Respon } } -type awsAwsjson11_deserializeOpCreateWorkgroup struct { +type awsAwsjson11_deserializeOpCreateUsageLimit struct { } -func (*awsAwsjson11_deserializeOpCreateWorkgroup) ID() string { +func (*awsAwsjson11_deserializeOpCreateUsageLimit) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpCreateWorkgroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCreateUsageLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -662,9 +665,9 @@ func (m *awsAwsjson11_deserializeOpCreateWorkgroup) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorCreateWorkgroup(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCreateUsageLimit(response, &metadata) } - output := &CreateWorkgroupOutput{} + output := &CreateUsageLimitOutput{} out.Result = output var buff [1024]byte @@ -684,7 +687,7 @@ func (m *awsAwsjson11_deserializeOpCreateWorkgroup) HandleDeserialize(ctx contex return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentCreateWorkgroupOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentCreateUsageLimitOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -698,7 +701,7 @@ func (m *awsAwsjson11_deserializeOpCreateWorkgroup) HandleDeserialize(ctx contex return out, metadata, err } -func awsAwsjson11_deserializeOpErrorCreateWorkgroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCreateUsageLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -742,17 +745,14 @@ func awsAwsjson11_deserializeOpErrorCreateWorkgroup(response *smithyhttp.Respons case strings.EqualFold("ConflictException", errorCode): return awsAwsjson11_deserializeErrorConflictException(response, errorBody) - case strings.EqualFold("InsufficientCapacityException", errorCode): - return awsAwsjson11_deserializeErrorInsufficientCapacityException(response, errorBody) - case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) - case strings.EqualFold("TooManyTagsException", errorCode): - return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) + case strings.EqualFold("ServiceQuotaExceededException", errorCode): + return awsAwsjson11_deserializeErrorServiceQuotaExceededException(response, errorBody) case strings.EqualFold("ValidationException", errorCode): return awsAwsjson11_deserializeErrorValidationException(response, errorBody) @@ -767,14 +767,14 @@ func awsAwsjson11_deserializeOpErrorCreateWorkgroup(response *smithyhttp.Respons } } -type awsAwsjson11_deserializeOpDeleteEndpointAccess struct { +type awsAwsjson11_deserializeOpCreateWorkgroup struct { } -func (*awsAwsjson11_deserializeOpDeleteEndpointAccess) ID() string { +func (*awsAwsjson11_deserializeOpCreateWorkgroup) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteEndpointAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpCreateWorkgroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -788,9 +788,9 @@ func (m *awsAwsjson11_deserializeOpDeleteEndpointAccess) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteEndpointAccess(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorCreateWorkgroup(response, &metadata) } - output := &DeleteEndpointAccessOutput{} + output := &CreateWorkgroupOutput{} out.Result = output var buff [1024]byte @@ -810,7 +810,7 @@ func (m *awsAwsjson11_deserializeOpDeleteEndpointAccess) HandleDeserialize(ctx c return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDeleteEndpointAccessOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentCreateWorkgroupOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -824,7 +824,7 @@ func (m *awsAwsjson11_deserializeOpDeleteEndpointAccess) HandleDeserialize(ctx c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteEndpointAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorCreateWorkgroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -868,12 +868,18 @@ func awsAwsjson11_deserializeOpErrorDeleteEndpointAccess(response *smithyhttp.Re case strings.EqualFold("ConflictException", errorCode): return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("InsufficientCapacityException", errorCode): + return awsAwsjson11_deserializeErrorInsufficientCapacityException(response, errorBody) + case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("TooManyTagsException", errorCode): + return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) + case strings.EqualFold("ValidationException", errorCode): return awsAwsjson11_deserializeErrorValidationException(response, errorBody) @@ -887,14 +893,14 @@ func awsAwsjson11_deserializeOpErrorDeleteEndpointAccess(response *smithyhttp.Re } } -type awsAwsjson11_deserializeOpDeleteNamespace struct { +type awsAwsjson11_deserializeOpDeleteCustomDomainAssociation struct { } -func (*awsAwsjson11_deserializeOpDeleteNamespace) ID() string { +func (*awsAwsjson11_deserializeOpDeleteCustomDomainAssociation) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteNamespace) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteCustomDomainAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -908,9 +914,9 @@ func (m *awsAwsjson11_deserializeOpDeleteNamespace) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteNamespace(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCustomDomainAssociation(response, &metadata) } - output := &DeleteNamespaceOutput{} + output := &DeleteCustomDomainAssociationOutput{} out.Result = output var buff [1024]byte @@ -930,7 +936,7 @@ func (m *awsAwsjson11_deserializeOpDeleteNamespace) HandleDeserialize(ctx contex return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDeleteNamespaceOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDeleteCustomDomainAssociationOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -944,7 +950,7 @@ func (m *awsAwsjson11_deserializeOpDeleteNamespace) HandleDeserialize(ctx contex return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteNamespace(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteCustomDomainAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -985,6 +991,9 @@ func awsAwsjson11_deserializeOpErrorDeleteNamespace(response *smithyhttp.Respons } switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): return awsAwsjson11_deserializeErrorConflictException(response, errorBody) @@ -994,6 +1003,9 @@ func awsAwsjson11_deserializeOpErrorDeleteNamespace(response *smithyhttp.Respons case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + case strings.EqualFold("ValidationException", errorCode): return awsAwsjson11_deserializeErrorValidationException(response, errorBody) @@ -1007,14 +1019,14 @@ func awsAwsjson11_deserializeOpErrorDeleteNamespace(response *smithyhttp.Respons } } -type awsAwsjson11_deserializeOpDeleteResourcePolicy struct { +type awsAwsjson11_deserializeOpDeleteEndpointAccess struct { } -func (*awsAwsjson11_deserializeOpDeleteResourcePolicy) ID() string { +func (*awsAwsjson11_deserializeOpDeleteEndpointAccess) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteResourcePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteEndpointAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1028,9 +1040,9 @@ func (m *awsAwsjson11_deserializeOpDeleteResourcePolicy) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteEndpointAccess(response, &metadata) } - output := &DeleteResourcePolicyOutput{} + output := &DeleteEndpointAccessOutput{} out.Result = output var buff [1024]byte @@ -1050,7 +1062,7 @@ func (m *awsAwsjson11_deserializeOpDeleteResourcePolicy) HandleDeserialize(ctx c return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDeleteResourcePolicyOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDeleteEndpointAccessOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -1064,7 +1076,7 @@ func (m *awsAwsjson11_deserializeOpDeleteResourcePolicy) HandleDeserialize(ctx c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteEndpointAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1105,6 +1117,9 @@ func awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response *smithyhttp.Re } switch { + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) @@ -1124,14 +1139,14 @@ func awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response *smithyhttp.Re } } -type awsAwsjson11_deserializeOpDeleteSnapshot struct { +type awsAwsjson11_deserializeOpDeleteNamespace struct { } -func (*awsAwsjson11_deserializeOpDeleteSnapshot) ID() string { +func (*awsAwsjson11_deserializeOpDeleteNamespace) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteNamespace) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1145,9 +1160,9 @@ func (m *awsAwsjson11_deserializeOpDeleteSnapshot) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteSnapshot(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteNamespace(response, &metadata) } - output := &DeleteSnapshotOutput{} + output := &DeleteNamespaceOutput{} out.Result = output var buff [1024]byte @@ -1167,7 +1182,7 @@ func (m *awsAwsjson11_deserializeOpDeleteSnapshot) HandleDeserialize(ctx context return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDeleteSnapshotOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDeleteNamespaceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -1181,7 +1196,7 @@ func (m *awsAwsjson11_deserializeOpDeleteSnapshot) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteNamespace(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1244,14 +1259,14 @@ func awsAwsjson11_deserializeOpErrorDeleteSnapshot(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpDeleteUsageLimit struct { +type awsAwsjson11_deserializeOpDeleteResourcePolicy struct { } -func (*awsAwsjson11_deserializeOpDeleteUsageLimit) ID() string { +func (*awsAwsjson11_deserializeOpDeleteResourcePolicy) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteUsageLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteResourcePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1265,9 +1280,9 @@ func (m *awsAwsjson11_deserializeOpDeleteUsageLimit) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteUsageLimit(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response, &metadata) } - output := &DeleteUsageLimitOutput{} + output := &DeleteResourcePolicyOutput{} out.Result = output var buff [1024]byte @@ -1287,7 +1302,7 @@ func (m *awsAwsjson11_deserializeOpDeleteUsageLimit) HandleDeserialize(ctx conte return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDeleteUsageLimitOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDeleteResourcePolicyOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -1301,7 +1316,7 @@ func (m *awsAwsjson11_deserializeOpDeleteUsageLimit) HandleDeserialize(ctx conte return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteUsageLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1342,9 +1357,6 @@ func awsAwsjson11_deserializeOpErrorDeleteUsageLimit(response *smithyhttp.Respon } switch { - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) - case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) @@ -1364,14 +1376,14 @@ func awsAwsjson11_deserializeOpErrorDeleteUsageLimit(response *smithyhttp.Respon } } -type awsAwsjson11_deserializeOpDeleteWorkgroup struct { +type awsAwsjson11_deserializeOpDeleteSnapshot struct { } -func (*awsAwsjson11_deserializeOpDeleteWorkgroup) ID() string { +func (*awsAwsjson11_deserializeOpDeleteSnapshot) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDeleteWorkgroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1385,9 +1397,9 @@ func (m *awsAwsjson11_deserializeOpDeleteWorkgroup) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDeleteWorkgroup(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteSnapshot(response, &metadata) } - output := &DeleteWorkgroupOutput{} + output := &DeleteSnapshotOutput{} out.Result = output var buff [1024]byte @@ -1407,7 +1419,7 @@ func (m *awsAwsjson11_deserializeOpDeleteWorkgroup) HandleDeserialize(ctx contex return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDeleteWorkgroupOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDeleteSnapshotOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -1421,7 +1433,7 @@ func (m *awsAwsjson11_deserializeOpDeleteWorkgroup) HandleDeserialize(ctx contex return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDeleteWorkgroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1484,14 +1496,14 @@ func awsAwsjson11_deserializeOpErrorDeleteWorkgroup(response *smithyhttp.Respons } } -type awsAwsjson11_deserializeOpGetCredentials struct { +type awsAwsjson11_deserializeOpDeleteUsageLimit struct { } -func (*awsAwsjson11_deserializeOpGetCredentials) ID() string { +func (*awsAwsjson11_deserializeOpDeleteUsageLimit) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetCredentials) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteUsageLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1505,9 +1517,9 @@ func (m *awsAwsjson11_deserializeOpGetCredentials) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetCredentials(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteUsageLimit(response, &metadata) } - output := &GetCredentialsOutput{} + output := &DeleteUsageLimitOutput{} out.Result = output var buff [1024]byte @@ -1527,7 +1539,7 @@ func (m *awsAwsjson11_deserializeOpGetCredentials) HandleDeserialize(ctx context return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetCredentialsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDeleteUsageLimitOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -1541,7 +1553,7 @@ func (m *awsAwsjson11_deserializeOpGetCredentials) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetCredentials(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteUsageLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1582,6 +1594,9 @@ func awsAwsjson11_deserializeOpErrorGetCredentials(response *smithyhttp.Response } switch { + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) @@ -1601,14 +1616,14 @@ func awsAwsjson11_deserializeOpErrorGetCredentials(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpGetEndpointAccess struct { +type awsAwsjson11_deserializeOpDeleteWorkgroup struct { } -func (*awsAwsjson11_deserializeOpGetEndpointAccess) ID() string { +func (*awsAwsjson11_deserializeOpDeleteWorkgroup) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetEndpointAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDeleteWorkgroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1622,9 +1637,9 @@ func (m *awsAwsjson11_deserializeOpGetEndpointAccess) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetEndpointAccess(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDeleteWorkgroup(response, &metadata) } - output := &GetEndpointAccessOutput{} + output := &DeleteWorkgroupOutput{} out.Result = output var buff [1024]byte @@ -1644,7 +1659,7 @@ func (m *awsAwsjson11_deserializeOpGetEndpointAccess) HandleDeserialize(ctx cont return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetEndpointAccessOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDeleteWorkgroupOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -1658,7 +1673,7 @@ func (m *awsAwsjson11_deserializeOpGetEndpointAccess) HandleDeserialize(ctx cont return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetEndpointAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDeleteWorkgroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1721,14 +1736,14 @@ func awsAwsjson11_deserializeOpErrorGetEndpointAccess(response *smithyhttp.Respo } } -type awsAwsjson11_deserializeOpGetNamespace struct { +type awsAwsjson11_deserializeOpGetCredentials struct { } -func (*awsAwsjson11_deserializeOpGetNamespace) ID() string { +func (*awsAwsjson11_deserializeOpGetCredentials) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetNamespace) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetCredentials) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1742,9 +1757,9 @@ func (m *awsAwsjson11_deserializeOpGetNamespace) HandleDeserialize(ctx context.C } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetNamespace(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetCredentials(response, &metadata) } - output := &GetNamespaceOutput{} + output := &GetCredentialsOutput{} out.Result = output var buff [1024]byte @@ -1764,7 +1779,7 @@ func (m *awsAwsjson11_deserializeOpGetNamespace) HandleDeserialize(ctx context.C return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetNamespaceOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetCredentialsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -1778,7 +1793,7 @@ func (m *awsAwsjson11_deserializeOpGetNamespace) HandleDeserialize(ctx context.C return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetNamespace(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetCredentials(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1838,14 +1853,14 @@ func awsAwsjson11_deserializeOpErrorGetNamespace(response *smithyhttp.Response, } } -type awsAwsjson11_deserializeOpGetRecoveryPoint struct { +type awsAwsjson11_deserializeOpGetCustomDomainAssociation struct { } -func (*awsAwsjson11_deserializeOpGetRecoveryPoint) ID() string { +func (*awsAwsjson11_deserializeOpGetCustomDomainAssociation) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetRecoveryPoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetCustomDomainAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1859,9 +1874,9 @@ func (m *awsAwsjson11_deserializeOpGetRecoveryPoint) HandleDeserialize(ctx conte } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetRecoveryPoint(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetCustomDomainAssociation(response, &metadata) } - output := &GetRecoveryPointOutput{} + output := &GetCustomDomainAssociationOutput{} out.Result = output var buff [1024]byte @@ -1881,7 +1896,7 @@ func (m *awsAwsjson11_deserializeOpGetRecoveryPoint) HandleDeserialize(ctx conte return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetRecoveryPointOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetCustomDomainAssociationOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -1895,7 +1910,7 @@ func (m *awsAwsjson11_deserializeOpGetRecoveryPoint) HandleDeserialize(ctx conte return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetRecoveryPoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetCustomDomainAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -1936,6 +1951,9 @@ func awsAwsjson11_deserializeOpErrorGetRecoveryPoint(response *smithyhttp.Respon } switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + case strings.EqualFold("ConflictException", errorCode): return awsAwsjson11_deserializeErrorConflictException(response, errorBody) @@ -1945,6 +1963,9 @@ func awsAwsjson11_deserializeOpErrorGetRecoveryPoint(response *smithyhttp.Respon case strings.EqualFold("ResourceNotFoundException", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) + case strings.EqualFold("ValidationException", errorCode): return awsAwsjson11_deserializeErrorValidationException(response, errorBody) @@ -1958,14 +1979,14 @@ func awsAwsjson11_deserializeOpErrorGetRecoveryPoint(response *smithyhttp.Respon } } -type awsAwsjson11_deserializeOpGetResourcePolicy struct { +type awsAwsjson11_deserializeOpGetEndpointAccess struct { } -func (*awsAwsjson11_deserializeOpGetResourcePolicy) ID() string { +func (*awsAwsjson11_deserializeOpGetEndpointAccess) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetResourcePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpGetEndpointAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -1979,9 +2000,366 @@ func (m *awsAwsjson11_deserializeOpGetResourcePolicy) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetResourcePolicy(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetEndpointAccess(response, &metadata) } - output := &GetResourcePolicyOutput{} + output := &GetEndpointAccessOutput{} + 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_deserializeOpDocumentGetEndpointAccessOutput(&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_deserializeOpErrorGetEndpointAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpGetNamespace struct { +} + +func (*awsAwsjson11_deserializeOpGetNamespace) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpGetNamespace) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorGetNamespace(response, &metadata) + } + output := &GetNamespaceOutput{} + 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_deserializeOpDocumentGetNamespaceOutput(&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_deserializeOpErrorGetNamespace(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpGetRecoveryPoint struct { +} + +func (*awsAwsjson11_deserializeOpGetRecoveryPoint) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpGetRecoveryPoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorGetRecoveryPoint(response, &metadata) + } + output := &GetRecoveryPointOutput{} + 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_deserializeOpDocumentGetRecoveryPointOutput(&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_deserializeOpErrorGetRecoveryPoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpGetResourcePolicy struct { +} + +func (*awsAwsjson11_deserializeOpGetResourcePolicy) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpGetResourcePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorGetResourcePolicy(response, &metadata) + } + output := &GetResourcePolicyOutput{} out.Result = output var buff [1024]byte @@ -2327,9 +2705,129 @@ func (m *awsAwsjson11_deserializeOpGetUsageLimit) HandleDeserialize(ctx context. } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetUsageLimit(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorGetUsageLimit(response, &metadata) + } + output := &GetUsageLimitOutput{} + 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_deserializeOpDocumentGetUsageLimitOutput(&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_deserializeOpErrorGetUsageLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsAwsjson11_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpGetWorkgroup struct { +} + +func (*awsAwsjson11_deserializeOpGetWorkgroup) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpGetWorkgroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorGetWorkgroup(response, &metadata) } - output := &GetUsageLimitOutput{} + output := &GetWorkgroupOutput{} out.Result = output var buff [1024]byte @@ -2349,7 +2847,7 @@ func (m *awsAwsjson11_deserializeOpGetUsageLimit) HandleDeserialize(ctx context. return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetUsageLimitOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentGetWorkgroupOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -2363,7 +2861,7 @@ func (m *awsAwsjson11_deserializeOpGetUsageLimit) HandleDeserialize(ctx context. return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetUsageLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorGetWorkgroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -2404,9 +2902,6 @@ func awsAwsjson11_deserializeOpErrorGetUsageLimit(response *smithyhttp.Response, } switch { - case strings.EqualFold("ConflictException", errorCode): - return awsAwsjson11_deserializeErrorConflictException(response, errorBody) - case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) @@ -2426,14 +2921,14 @@ func awsAwsjson11_deserializeOpErrorGetUsageLimit(response *smithyhttp.Response, } } -type awsAwsjson11_deserializeOpGetWorkgroup struct { +type awsAwsjson11_deserializeOpListCustomDomainAssociations struct { } -func (*awsAwsjson11_deserializeOpGetWorkgroup) ID() string { +func (*awsAwsjson11_deserializeOpListCustomDomainAssociations) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpGetWorkgroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpListCustomDomainAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -2447,9 +2942,9 @@ func (m *awsAwsjson11_deserializeOpGetWorkgroup) HandleDeserialize(ctx context.C } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorGetWorkgroup(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorListCustomDomainAssociations(response, &metadata) } - output := &GetWorkgroupOutput{} + output := &ListCustomDomainAssociationsOutput{} out.Result = output var buff [1024]byte @@ -2469,7 +2964,7 @@ func (m *awsAwsjson11_deserializeOpGetWorkgroup) HandleDeserialize(ctx context.C return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentGetWorkgroupOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentListCustomDomainAssociationsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -2483,7 +2978,7 @@ func (m *awsAwsjson11_deserializeOpGetWorkgroup) HandleDeserialize(ctx context.C return out, metadata, err } -func awsAwsjson11_deserializeOpErrorGetWorkgroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorListCustomDomainAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -2524,11 +3019,17 @@ func awsAwsjson11_deserializeOpErrorGetWorkgroup(response *smithyhttp.Response, } switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + case strings.EqualFold("InternalServerException", errorCode): return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) - case strings.EqualFold("ResourceNotFoundException", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) + case strings.EqualFold("InvalidPaginationException", errorCode): + return awsAwsjson11_deserializeErrorInvalidPaginationException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) case strings.EqualFold("ValidationException", errorCode): return awsAwsjson11_deserializeErrorValidationException(response, errorBody) @@ -4211,6 +4712,132 @@ func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, } } +type awsAwsjson11_deserializeOpUpdateCustomDomainAssociation struct { +} + +func (*awsAwsjson11_deserializeOpUpdateCustomDomainAssociation) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpUpdateCustomDomainAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsAwsjson11_deserializeOpErrorUpdateCustomDomainAssociation(response, &metadata) + } + output := &UpdateCustomDomainAssociationOutput{} + 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_deserializeOpDocumentUpdateCustomDomainAssociationOutput(&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_deserializeOpErrorUpdateCustomDomainAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsAwsjson11_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundException(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_deserializeOpUpdateEndpointAccess struct { } @@ -5252,6 +5879,111 @@ func awsAwsjson11_deserializeDocumentAccountIdList(v *[]string, value interface{ return nil } +func awsAwsjson11_deserializeDocumentAssociation(v **types.Association, 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.Association + if *v == nil { + sv = &types.Association{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "customDomainCertificateArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected CustomDomainCertificateArnString to be of type string, got %T instead", value) + } + sv.CustomDomainCertificateArn = ptr.String(jtv) + } + + case "customDomainCertificateExpiryTime": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) + } + t, err := smithytime.ParseDateTime(jtv) + if err != nil { + return err + } + sv.CustomDomainCertificateExpiryTime = ptr.Time(t) + } + + case "customDomainName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected CustomDomainName to be of type string, got %T instead", value) + } + sv.CustomDomainName = ptr.String(jtv) + } + + case "workgroupName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected WorkgroupName to be of type string, got %T instead", value) + } + sv.WorkgroupName = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentAssociationList(v *[]types.Association, 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.Association + if *v == nil { + cv = []types.Association{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.Association + destAddr := &col + if err := awsAwsjson11_deserializeDocumentAssociation(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + func awsAwsjson11_deserializeDocumentConfigParameter(v **types.ConfigParameter, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -7571,7 +8303,29 @@ func awsAwsjson11_deserializeDocumentWorkgroup(v **types.Workgroup, value interf return err } - case "creationDate": + case "creationDate": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) + } + t, err := smithytime.ParseDateTime(jtv) + if err != nil { + return err + } + sv.CreationDate = ptr.Time(t) + } + + case "customDomainCertificateArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected CustomDomainCertificateArnString to be of type string, got %T instead", value) + } + sv.CustomDomainCertificateArn = ptr.String(jtv) + } + + case "customDomainCertificateExpiryTime": if value != nil { jtv, ok := value.(string) if !ok { @@ -7581,7 +8335,16 @@ func awsAwsjson11_deserializeDocumentWorkgroup(v **types.Workgroup, value interf if err != nil { return err } - sv.CreationDate = ptr.Time(t) + sv.CustomDomainCertificateExpiryTime = ptr.Time(t) + } + + case "customDomainName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected CustomDomainName to be of type string, got %T instead", value) + } + sv.CustomDomainName = ptr.String(jtv) } case "endpoint": @@ -7772,6 +8535,77 @@ func awsAwsjson11_deserializeOpDocumentConvertRecoveryPointToSnapshotOutput(v ** return nil } +func awsAwsjson11_deserializeOpDocumentCreateCustomDomainAssociationOutput(v **CreateCustomDomainAssociationOutput, 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 *CreateCustomDomainAssociationOutput + if *v == nil { + sv = &CreateCustomDomainAssociationOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "customDomainCertificateArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected CustomDomainCertificateArnString to be of type string, got %T instead", value) + } + sv.CustomDomainCertificateArn = ptr.String(jtv) + } + + case "customDomainCertificateExpiryTime": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) + } + t, err := smithytime.ParseDateTime(jtv) + if err != nil { + return err + } + sv.CustomDomainCertificateExpiryTime = ptr.Time(t) + } + + case "customDomainName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected CustomDomainName to be of type string, got %T instead", value) + } + sv.CustomDomainName = ptr.String(jtv) + } + + case "workgroupName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected WorkgroupName to be of type string, got %T instead", value) + } + sv.WorkgroupName = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentCreateEndpointAccessOutput(v **CreateEndpointAccessOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -7952,6 +8786,37 @@ func awsAwsjson11_deserializeOpDocumentCreateWorkgroupOutput(v **CreateWorkgroup return nil } +func awsAwsjson11_deserializeOpDocumentDeleteCustomDomainAssociationOutput(v **DeleteCustomDomainAssociationOutput, 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 *DeleteCustomDomainAssociationOutput + if *v == nil { + sv = &DeleteCustomDomainAssociationOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentDeleteEndpointAccessOutput(v **DeleteEndpointAccessOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -8244,6 +9109,77 @@ func awsAwsjson11_deserializeOpDocumentGetCredentialsOutput(v **GetCredentialsOu return nil } +func awsAwsjson11_deserializeOpDocumentGetCustomDomainAssociationOutput(v **GetCustomDomainAssociationOutput, 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 *GetCustomDomainAssociationOutput + if *v == nil { + sv = &GetCustomDomainAssociationOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "customDomainCertificateArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected CustomDomainCertificateArnString to be of type string, got %T instead", value) + } + sv.CustomDomainCertificateArn = ptr.String(jtv) + } + + case "customDomainCertificateExpiryTime": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) + } + t, err := smithytime.ParseDateTime(jtv) + if err != nil { + return err + } + sv.CustomDomainCertificateExpiryTime = ptr.Time(t) + } + + case "customDomainName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected CustomDomainName to be of type string, got %T instead", value) + } + sv.CustomDomainName = ptr.String(jtv) + } + + case "workgroupName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected WorkgroupName to be of type string, got %T instead", value) + } + sv.WorkgroupName = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentGetEndpointAccessOutput(v **GetEndpointAccessOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -8532,6 +9468,51 @@ func awsAwsjson11_deserializeOpDocumentGetWorkgroupOutput(v **GetWorkgroupOutput return nil } +func awsAwsjson11_deserializeOpDocumentListCustomDomainAssociationsOutput(v **ListCustomDomainAssociationsOutput, 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 *ListCustomDomainAssociationsOutput + if *v == nil { + sv = &ListCustomDomainAssociationsOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "associations": + if err := awsAwsjson11_deserializeDocumentAssociationList(&sv.Associations, value); err != nil { + return err + } + + case "nextToken": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) + } + sv.NextToken = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentListEndpointAccessOutput(v **ListEndpointAccessOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -9116,6 +10097,77 @@ func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutp return nil } +func awsAwsjson11_deserializeOpDocumentUpdateCustomDomainAssociationOutput(v **UpdateCustomDomainAssociationOutput, 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 *UpdateCustomDomainAssociationOutput + if *v == nil { + sv = &UpdateCustomDomainAssociationOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "customDomainCertificateArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected CustomDomainCertificateArnString to be of type string, got %T instead", value) + } + sv.CustomDomainCertificateArn = ptr.String(jtv) + } + + case "customDomainCertificateExpiryTime": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) + } + t, err := smithytime.ParseDateTime(jtv) + if err != nil { + return err + } + sv.CustomDomainCertificateExpiryTime = ptr.Time(t) + } + + case "customDomainName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected CustomDomainName to be of type string, got %T instead", value) + } + sv.CustomDomainName = ptr.String(jtv) + } + + case "workgroupName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected WorkgroupName to be of type string, got %T instead", value) + } + sv.WorkgroupName = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentUpdateEndpointAccessOutput(v **UpdateEndpointAccessOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) diff --git a/service/redshiftserverless/generated.json b/service/redshiftserverless/generated.json index 002b9380cb3..714eabe0290 100644 --- a/service/redshiftserverless/generated.json +++ b/service/redshiftserverless/generated.json @@ -10,11 +10,13 @@ "api_client.go", "api_client_test.go", "api_op_ConvertRecoveryPointToSnapshot.go", + "api_op_CreateCustomDomainAssociation.go", "api_op_CreateEndpointAccess.go", "api_op_CreateNamespace.go", "api_op_CreateSnapshot.go", "api_op_CreateUsageLimit.go", "api_op_CreateWorkgroup.go", + "api_op_DeleteCustomDomainAssociation.go", "api_op_DeleteEndpointAccess.go", "api_op_DeleteNamespace.go", "api_op_DeleteResourcePolicy.go", @@ -22,6 +24,7 @@ "api_op_DeleteUsageLimit.go", "api_op_DeleteWorkgroup.go", "api_op_GetCredentials.go", + "api_op_GetCustomDomainAssociation.go", "api_op_GetEndpointAccess.go", "api_op_GetNamespace.go", "api_op_GetRecoveryPoint.go", @@ -30,6 +33,7 @@ "api_op_GetTableRestoreStatus.go", "api_op_GetUsageLimit.go", "api_op_GetWorkgroup.go", + "api_op_ListCustomDomainAssociations.go", "api_op_ListEndpointAccess.go", "api_op_ListNamespaces.go", "api_op_ListRecoveryPoints.go", @@ -44,6 +48,7 @@ "api_op_RestoreTableFromSnapshot.go", "api_op_TagResource.go", "api_op_UntagResource.go", + "api_op_UpdateCustomDomainAssociation.go", "api_op_UpdateEndpointAccess.go", "api_op_UpdateNamespace.go", "api_op_UpdateSnapshot.go", diff --git a/service/redshiftserverless/serializers.go b/service/redshiftserverless/serializers.go index 50b1e8d83f6..3107d7ec4a4 100644 --- a/service/redshiftserverless/serializers.go +++ b/service/redshiftserverless/serializers.go @@ -71,6 +71,61 @@ func (m *awsAwsjson11_serializeOpConvertRecoveryPointToSnapshot) HandleSerialize return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpCreateCustomDomainAssociation struct { +} + +func (*awsAwsjson11_serializeOpCreateCustomDomainAssociation) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpCreateCustomDomainAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*CreateCustomDomainAssociationInput) + _ = 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("RedshiftServerless.CreateCustomDomainAssociation") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentCreateCustomDomainAssociationInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsjson11_serializeOpCreateEndpointAccess struct { } @@ -346,6 +401,61 @@ func (m *awsAwsjson11_serializeOpCreateWorkgroup) HandleSerialize(ctx context.Co return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpDeleteCustomDomainAssociation struct { +} + +func (*awsAwsjson11_serializeOpDeleteCustomDomainAssociation) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpDeleteCustomDomainAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*DeleteCustomDomainAssociationInput) + _ = 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("RedshiftServerless.DeleteCustomDomainAssociation") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentDeleteCustomDomainAssociationInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsjson11_serializeOpDeleteEndpointAccess struct { } @@ -731,6 +841,61 @@ func (m *awsAwsjson11_serializeOpGetCredentials) HandleSerialize(ctx context.Con return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpGetCustomDomainAssociation struct { +} + +func (*awsAwsjson11_serializeOpGetCustomDomainAssociation) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpGetCustomDomainAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*GetCustomDomainAssociationInput) + _ = 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("RedshiftServerless.GetCustomDomainAssociation") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentGetCustomDomainAssociationInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsjson11_serializeOpGetEndpointAccess struct { } @@ -1171,6 +1336,61 @@ func (m *awsAwsjson11_serializeOpGetWorkgroup) HandleSerialize(ctx context.Conte return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpListCustomDomainAssociations struct { +} + +func (*awsAwsjson11_serializeOpListCustomDomainAssociations) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpListCustomDomainAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*ListCustomDomainAssociationsInput) + _ = 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("RedshiftServerless.ListCustomDomainAssociations") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentListCustomDomainAssociationsInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsjson11_serializeOpListEndpointAccess struct { } @@ -1941,6 +2161,61 @@ func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Cont return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpUpdateCustomDomainAssociation struct { +} + +func (*awsAwsjson11_serializeOpUpdateCustomDomainAssociation) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpUpdateCustomDomainAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*UpdateCustomDomainAssociationInput) + _ = 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("RedshiftServerless.UpdateCustomDomainAssociation") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentUpdateCustomDomainAssociationInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} + type awsAwsjson11_serializeOpUpdateEndpointAccess struct { } @@ -2370,6 +2645,28 @@ func awsAwsjson11_serializeOpDocumentConvertRecoveryPointToSnapshotInput(v *Conv return nil } +func awsAwsjson11_serializeOpDocumentCreateCustomDomainAssociationInput(v *CreateCustomDomainAssociationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.CustomDomainCertificateArn != nil { + ok := object.Key("customDomainCertificateArn") + ok.String(*v.CustomDomainCertificateArn) + } + + if v.CustomDomainName != nil { + ok := object.Key("customDomainName") + ok.String(*v.CustomDomainName) + } + + if v.WorkgroupName != nil { + ok := object.Key("workgroupName") + ok.String(*v.WorkgroupName) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentCreateEndpointAccessInput(v *CreateEndpointAccessInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -2595,6 +2892,23 @@ func awsAwsjson11_serializeOpDocumentCreateWorkgroupInput(v *CreateWorkgroupInpu return nil } +func awsAwsjson11_serializeOpDocumentDeleteCustomDomainAssociationInput(v *DeleteCustomDomainAssociationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.CustomDomainName != nil { + ok := object.Key("customDomainName") + ok.String(*v.CustomDomainName) + } + + if v.WorkgroupName != nil { + ok := object.Key("workgroupName") + ok.String(*v.WorkgroupName) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentDeleteEndpointAccessInput(v *DeleteEndpointAccessInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -2681,6 +2995,11 @@ func awsAwsjson11_serializeOpDocumentGetCredentialsInput(v *GetCredentialsInput, object := value.Object() defer object.Close() + if v.CustomDomainName != nil { + ok := object.Key("customDomainName") + ok.String(*v.CustomDomainName) + } + if v.DbName != nil { ok := object.Key("dbName") ok.String(*v.DbName) @@ -2699,6 +3018,23 @@ func awsAwsjson11_serializeOpDocumentGetCredentialsInput(v *GetCredentialsInput, return nil } +func awsAwsjson11_serializeOpDocumentGetCustomDomainAssociationInput(v *GetCustomDomainAssociationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.CustomDomainName != nil { + ok := object.Key("customDomainName") + ok.String(*v.CustomDomainName) + } + + if v.WorkgroupName != nil { + ok := object.Key("workgroupName") + ok.String(*v.WorkgroupName) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentGetEndpointAccessInput(v *GetEndpointAccessInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -2805,6 +3141,33 @@ func awsAwsjson11_serializeOpDocumentGetWorkgroupInput(v *GetWorkgroupInput, val return nil } +func awsAwsjson11_serializeOpDocumentListCustomDomainAssociationsInput(v *ListCustomDomainAssociationsInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.CustomDomainCertificateArn != nil { + ok := object.Key("customDomainCertificateArn") + ok.String(*v.CustomDomainCertificateArn) + } + + if v.CustomDomainName != nil { + ok := object.Key("customDomainName") + ok.String(*v.CustomDomainName) + } + + if v.MaxResults != nil { + ok := object.Key("maxResults") + ok.Integer(*v.MaxResults) + } + + if v.NextToken != nil { + ok := object.Key("nextToken") + ok.String(*v.NextToken) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentListEndpointAccessInput(v *ListEndpointAccessInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -3187,6 +3550,28 @@ func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, v return nil } +func awsAwsjson11_serializeOpDocumentUpdateCustomDomainAssociationInput(v *UpdateCustomDomainAssociationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.CustomDomainCertificateArn != nil { + ok := object.Key("customDomainCertificateArn") + ok.String(*v.CustomDomainCertificateArn) + } + + if v.CustomDomainName != nil { + ok := object.Key("customDomainName") + ok.String(*v.CustomDomainName) + } + + if v.WorkgroupName != nil { + ok := object.Key("workgroupName") + ok.String(*v.WorkgroupName) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentUpdateEndpointAccessInput(v *UpdateEndpointAccessInput, value smithyjson.Value) error { object := value.Object() defer object.Close() diff --git a/service/redshiftserverless/types/types.go b/service/redshiftserverless/types/types.go index 7dfbbce01ed..9c61c1d4a7c 100644 --- a/service/redshiftserverless/types/types.go +++ b/service/redshiftserverless/types/types.go @@ -7,6 +7,24 @@ import ( "time" ) +// An object that represents the custom domain name association. +type Association struct { + + // The custom domain name’s certificate Amazon resource name (ARN). + CustomDomainCertificateArn *string + + // The expiration time for the certificate. + CustomDomainCertificateExpiryTime *time.Time + + // The custom domain name associated with the workgroup. + CustomDomainName *string + + // The name of the workgroup associated with the database. + WorkgroupName *string + + noSmithyDocumentSerde +} + // An array of key-value pairs to set for advanced control over Amazon Redshift // Serverless. type ConfigParameter struct { @@ -415,6 +433,15 @@ type Workgroup struct { // The creation date of the workgroup. CreationDate *time.Time + // The custom domain name’s certificate Amazon resource name (ARN). + CustomDomainCertificateArn *string + + // The expiration time for the certificate. + CustomDomainCertificateExpiryTime *time.Time + + // The custom domain name associated with the workgroup. + CustomDomainName *string + // The endpoint that is created from the workgroup. Endpoint *Endpoint diff --git a/service/redshiftserverless/validators.go b/service/redshiftserverless/validators.go index 4ca13ca1350..cbfac379f03 100644 --- a/service/redshiftserverless/validators.go +++ b/service/redshiftserverless/validators.go @@ -30,6 +30,26 @@ func (m *validateOpConvertRecoveryPointToSnapshot) HandleInitialize(ctx context. return next.HandleInitialize(ctx, in) } +type validateOpCreateCustomDomainAssociation struct { +} + +func (*validateOpCreateCustomDomainAssociation) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateCustomDomainAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateCustomDomainAssociationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateCustomDomainAssociationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpCreateEndpointAccess struct { } @@ -130,6 +150,26 @@ func (m *validateOpCreateWorkgroup) HandleInitialize(ctx context.Context, in mid return next.HandleInitialize(ctx, in) } +type validateOpDeleteCustomDomainAssociation struct { +} + +func (*validateOpDeleteCustomDomainAssociation) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteCustomDomainAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteCustomDomainAssociationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteCustomDomainAssociationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDeleteEndpointAccess struct { } @@ -250,21 +290,21 @@ func (m *validateOpDeleteWorkgroup) HandleInitialize(ctx context.Context, in mid return next.HandleInitialize(ctx, in) } -type validateOpGetCredentials struct { +type validateOpGetCustomDomainAssociation struct { } -func (*validateOpGetCredentials) ID() string { +func (*validateOpGetCustomDomainAssociation) ID() string { return "OperationInputValidation" } -func (m *validateOpGetCredentials) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( +func (m *validateOpGetCustomDomainAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( out middleware.InitializeOutput, metadata middleware.Metadata, err error, ) { - input, ok := in.Parameters.(*GetCredentialsInput) + input, ok := in.Parameters.(*GetCustomDomainAssociationInput) if !ok { return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) } - if err := validateOpGetCredentialsInput(input); err != nil { + if err := validateOpGetCustomDomainAssociationInput(input); err != nil { return out, metadata, err } return next.HandleInitialize(ctx, in) @@ -550,6 +590,26 @@ func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middl return next.HandleInitialize(ctx, in) } +type validateOpUpdateCustomDomainAssociation struct { +} + +func (*validateOpUpdateCustomDomainAssociation) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpUpdateCustomDomainAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*UpdateCustomDomainAssociationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpUpdateCustomDomainAssociationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpUpdateEndpointAccess struct { } @@ -654,6 +714,10 @@ func addOpConvertRecoveryPointToSnapshotValidationMiddleware(stack *middleware.S return stack.Initialize.Add(&validateOpConvertRecoveryPointToSnapshot{}, middleware.After) } +func addOpCreateCustomDomainAssociationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateCustomDomainAssociation{}, middleware.After) +} + func addOpCreateEndpointAccessValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateEndpointAccess{}, middleware.After) } @@ -674,6 +738,10 @@ func addOpCreateWorkgroupValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateWorkgroup{}, middleware.After) } +func addOpDeleteCustomDomainAssociationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteCustomDomainAssociation{}, middleware.After) +} + func addOpDeleteEndpointAccessValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteEndpointAccess{}, middleware.After) } @@ -698,8 +766,8 @@ func addOpDeleteWorkgroupValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteWorkgroup{}, middleware.After) } -func addOpGetCredentialsValidationMiddleware(stack *middleware.Stack) error { - return stack.Initialize.Add(&validateOpGetCredentials{}, middleware.After) +func addOpGetCustomDomainAssociationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpGetCustomDomainAssociation{}, middleware.After) } func addOpGetEndpointAccessValidationMiddleware(stack *middleware.Stack) error { @@ -758,6 +826,10 @@ func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) } +func addOpUpdateCustomDomainAssociationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpUpdateCustomDomainAssociation{}, middleware.After) +} + func addOpUpdateEndpointAccessValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpUpdateEndpointAccess{}, middleware.After) } @@ -836,6 +908,27 @@ func validateOpConvertRecoveryPointToSnapshotInput(v *ConvertRecoveryPointToSnap } } +func validateOpCreateCustomDomainAssociationInput(v *CreateCustomDomainAssociationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CreateCustomDomainAssociationInput"} + if v.WorkgroupName == nil { + invalidParams.Add(smithy.NewErrParamRequired("WorkgroupName")) + } + if v.CustomDomainName == nil { + invalidParams.Add(smithy.NewErrParamRequired("CustomDomainName")) + } + if v.CustomDomainCertificateArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("CustomDomainCertificateArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpCreateEndpointAccessInput(v *CreateEndpointAccessInput) error { if v == nil { return nil @@ -944,6 +1037,24 @@ func validateOpCreateWorkgroupInput(v *CreateWorkgroupInput) error { } } +func validateOpDeleteCustomDomainAssociationInput(v *DeleteCustomDomainAssociationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DeleteCustomDomainAssociationInput"} + if v.WorkgroupName == nil { + invalidParams.Add(smithy.NewErrParamRequired("WorkgroupName")) + } + if v.CustomDomainName == nil { + invalidParams.Add(smithy.NewErrParamRequired("CustomDomainName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpDeleteEndpointAccessInput(v *DeleteEndpointAccessInput) error { if v == nil { return nil @@ -1034,11 +1145,14 @@ func validateOpDeleteWorkgroupInput(v *DeleteWorkgroupInput) error { } } -func validateOpGetCredentialsInput(v *GetCredentialsInput) error { +func validateOpGetCustomDomainAssociationInput(v *GetCustomDomainAssociationInput) error { if v == nil { return nil } - invalidParams := smithy.InvalidParamsError{Context: "GetCredentialsInput"} + invalidParams := smithy.InvalidParamsError{Context: "GetCustomDomainAssociationInput"} + if v.CustomDomainName == nil { + invalidParams.Add(smithy.NewErrParamRequired("CustomDomainName")) + } if v.WorkgroupName == nil { invalidParams.Add(smithy.NewErrParamRequired("WorkgroupName")) } @@ -1296,6 +1410,27 @@ func validateOpUntagResourceInput(v *UntagResourceInput) error { } } +func validateOpUpdateCustomDomainAssociationInput(v *UpdateCustomDomainAssociationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "UpdateCustomDomainAssociationInput"} + if v.WorkgroupName == nil { + invalidParams.Add(smithy.NewErrParamRequired("WorkgroupName")) + } + if v.CustomDomainName == nil { + invalidParams.Add(smithy.NewErrParamRequired("CustomDomainName")) + } + if v.CustomDomainCertificateArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("CustomDomainCertificateArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpUpdateEndpointAccessInput(v *UpdateEndpointAccessInput) error { if v == nil { return nil diff --git a/service/resiliencehub/api_op_AddDraftAppVersionResourceMappings.go b/service/resiliencehub/api_op_AddDraftAppVersionResourceMappings.go index 6a92cc5471e..703c319b825 100644 --- a/service/resiliencehub/api_op_AddDraftAppVersionResourceMappings.go +++ b/service/resiliencehub/api_op_AddDraftAppVersionResourceMappings.go @@ -16,8 +16,12 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Adds the resource mapping for the draft application version. You can also -// update an existing resource mapping to a new physical resource. +// Adds the source of resource-maps to the draft version of an application. During +// assessment, Resilience Hub will use these resource-maps to resolve the latest +// physical ID for each resource in the application template. For more information +// about different types of resources suported by Resilience Hub and how to add +// them in your application, see Step 2: How is your application managed? (https://docs.aws.amazon.com/resilience-hub/latest/userguide/how-app-manage.html) +// in the Resilience Hub User Guide. func (c *Client) AddDraftAppVersionResourceMappings(ctx context.Context, params *AddDraftAppVersionResourceMappingsInput, optFns ...func(*Options)) (*AddDraftAppVersionResourceMappingsOutput, error) { if params == nil { params = &AddDraftAppVersionResourceMappingsInput{} @@ -38,7 +42,7 @@ type AddDraftAppVersionResourceMappingsInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -60,7 +64,7 @@ type AddDraftAppVersionResourceMappingsOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_BatchUpdateRecommendationStatus.go b/service/resiliencehub/api_op_BatchUpdateRecommendationStatus.go index c7253cef30a..d11a76b8408 100644 --- a/service/resiliencehub/api_op_BatchUpdateRecommendationStatus.go +++ b/service/resiliencehub/api_op_BatchUpdateRecommendationStatus.go @@ -37,7 +37,7 @@ type BatchUpdateRecommendationStatusInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -56,7 +56,7 @@ type BatchUpdateRecommendationStatusOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_CreateApp.go b/service/resiliencehub/api_op_CreateApp.go index 05b34f1ddb1..9c472b3e8df 100644 --- a/service/resiliencehub/api_op_CreateApp.go +++ b/service/resiliencehub/api_op_CreateApp.go @@ -75,7 +75,7 @@ type CreateAppInput struct { // Amazon Resource Name (ARN) of the resiliency policy. The format for this ARN // is: arn: partition :resiliencehub: region : account :resiliency-policy/ policy-id // . For more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. PolicyArn *string // Tags assigned to the resource. A tag is a label that you assign to an Amazon diff --git a/service/resiliencehub/api_op_CreateAppVersionAppComponent.go b/service/resiliencehub/api_op_CreateAppVersionAppComponent.go index a78bbd1fcbb..ae2c334e1bc 100644 --- a/service/resiliencehub/api_op_CreateAppVersionAppComponent.go +++ b/service/resiliencehub/api_op_CreateAppVersionAppComponent.go @@ -40,7 +40,7 @@ type CreateAppVersionAppComponentInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -77,7 +77,7 @@ type CreateAppVersionAppComponentOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_CreateAppVersionResource.go b/service/resiliencehub/api_op_CreateAppVersionResource.go index 413f4267781..db4e400b097 100644 --- a/service/resiliencehub/api_op_CreateAppVersionResource.go +++ b/service/resiliencehub/api_op_CreateAppVersionResource.go @@ -45,7 +45,7 @@ type CreateAppVersionResourceInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -96,7 +96,7 @@ type CreateAppVersionResourceOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_CreateRecommendationTemplate.go b/service/resiliencehub/api_op_CreateRecommendationTemplate.go index 2eec5c0b4a6..addbe3ce00c 100644 --- a/service/resiliencehub/api_op_CreateRecommendationTemplate.go +++ b/service/resiliencehub/api_op_CreateRecommendationTemplate.go @@ -37,7 +37,7 @@ type CreateRecommendationTemplateInput struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string diff --git a/service/resiliencehub/api_op_CreateResiliencyPolicy.go b/service/resiliencehub/api_op_CreateResiliencyPolicy.go index 7f007ec562d..4ae012d1744 100644 --- a/service/resiliencehub/api_op_CreateResiliencyPolicy.go +++ b/service/resiliencehub/api_op_CreateResiliencyPolicy.go @@ -16,7 +16,12 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Creates a resiliency policy for an application. +// Creates a resiliency policy for an application. Resilience Hub allows you to +// provide a value of zero for rtoInSecs and rpoInSecs of your resiliency policy. +// But, while assessing your application, the lowest possible assessment result is +// near zero. Hence, if you provide value zero for rtoInSecs and rpoInSecs , the +// estimated workload RTO and estimated workload RPO result will be near zero and +// the Compliance status for your application will be set to Policy breached. func (c *Client) CreateResiliencyPolicy(ctx context.Context, params *CreateResiliencyPolicyInput, optFns ...func(*Options)) (*CreateResiliencyPolicyOutput, error) { if params == nil { params = &CreateResiliencyPolicyInput{} diff --git a/service/resiliencehub/api_op_DeleteApp.go b/service/resiliencehub/api_op_DeleteApp.go index dddb5fd6e14..e3d7d4729de 100644 --- a/service/resiliencehub/api_op_DeleteApp.go +++ b/service/resiliencehub/api_op_DeleteApp.go @@ -37,7 +37,7 @@ type DeleteAppInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -58,7 +58,7 @@ type DeleteAppOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_DeleteAppAssessment.go b/service/resiliencehub/api_op_DeleteAppAssessment.go index 2457a444b4e..beed394806e 100644 --- a/service/resiliencehub/api_op_DeleteAppAssessment.go +++ b/service/resiliencehub/api_op_DeleteAppAssessment.go @@ -38,7 +38,7 @@ type DeleteAppAssessmentInput struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string @@ -56,7 +56,7 @@ type DeleteAppAssessmentOutput struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string diff --git a/service/resiliencehub/api_op_DeleteAppInputSource.go b/service/resiliencehub/api_op_DeleteAppInputSource.go index 56de7c6764c..83d0a9a5c86 100644 --- a/service/resiliencehub/api_op_DeleteAppInputSource.go +++ b/service/resiliencehub/api_op_DeleteAppInputSource.go @@ -38,7 +38,7 @@ type DeleteAppInputSourceInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -55,7 +55,7 @@ type DeleteAppInputSourceInput struct { // The Amazon Resource Name (ARN) of the imported resource you want to remove from // the Resilience Hub application. For more information about ARNs, see Amazon // Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. SourceArn *string // The imported Terraform s3 state file you want to remove from the Resilience Hub @@ -70,7 +70,7 @@ type DeleteAppInputSourceOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. AppArn *string // Name of the input source from where the application resource is imported from. diff --git a/service/resiliencehub/api_op_DeleteAppVersionAppComponent.go b/service/resiliencehub/api_op_DeleteAppVersionAppComponent.go index ed93075cfab..c24ab68aeb7 100644 --- a/service/resiliencehub/api_op_DeleteAppVersionAppComponent.go +++ b/service/resiliencehub/api_op_DeleteAppVersionAppComponent.go @@ -42,7 +42,7 @@ type DeleteAppVersionAppComponentInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -65,7 +65,7 @@ type DeleteAppVersionAppComponentOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_DeleteAppVersionResource.go b/service/resiliencehub/api_op_DeleteAppVersionResource.go index 908eed0a829..e56bdab1c9a 100644 --- a/service/resiliencehub/api_op_DeleteAppVersionResource.go +++ b/service/resiliencehub/api_op_DeleteAppVersionResource.go @@ -43,7 +43,7 @@ type DeleteAppVersionResourceInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -76,7 +76,7 @@ type DeleteAppVersionResourceOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_DeleteResiliencyPolicy.go b/service/resiliencehub/api_op_DeleteResiliencyPolicy.go index fbdf8d5d3d0..d42e529bc96 100644 --- a/service/resiliencehub/api_op_DeleteResiliencyPolicy.go +++ b/service/resiliencehub/api_op_DeleteResiliencyPolicy.go @@ -36,7 +36,7 @@ type DeleteResiliencyPolicyInput struct { // Amazon Resource Name (ARN) of the resiliency policy. The format for this ARN // is: arn: partition :resiliencehub: region : account :resiliency-policy/ policy-id // . For more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. PolicyArn *string @@ -54,7 +54,7 @@ type DeleteResiliencyPolicyOutput struct { // Amazon Resource Name (ARN) of the resiliency policy. The format for this ARN // is: arn: partition :resiliencehub: region : account :resiliency-policy/ policy-id // . For more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. PolicyArn *string diff --git a/service/resiliencehub/api_op_DescribeApp.go b/service/resiliencehub/api_op_DescribeApp.go index dd64d76bd28..eb7bcc7c337 100644 --- a/service/resiliencehub/api_op_DescribeApp.go +++ b/service/resiliencehub/api_op_DescribeApp.go @@ -37,7 +37,7 @@ type DescribeAppInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_DescribeAppAssessment.go b/service/resiliencehub/api_op_DescribeAppAssessment.go index b204d6d2c74..09d683ed895 100644 --- a/service/resiliencehub/api_op_DescribeAppAssessment.go +++ b/service/resiliencehub/api_op_DescribeAppAssessment.go @@ -37,7 +37,7 @@ type DescribeAppAssessmentInput struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string diff --git a/service/resiliencehub/api_op_DescribeAppVersion.go b/service/resiliencehub/api_op_DescribeAppVersion.go index fa3501a307e..1bc59af817c 100644 --- a/service/resiliencehub/api_op_DescribeAppVersion.go +++ b/service/resiliencehub/api_op_DescribeAppVersion.go @@ -36,7 +36,7 @@ type DescribeAppVersionInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -54,7 +54,7 @@ type DescribeAppVersionOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_DescribeAppVersionAppComponent.go b/service/resiliencehub/api_op_DescribeAppVersionAppComponent.go index 10c97165286..38e3ee8ade8 100644 --- a/service/resiliencehub/api_op_DescribeAppVersionAppComponent.go +++ b/service/resiliencehub/api_op_DescribeAppVersionAppComponent.go @@ -37,7 +37,7 @@ type DescribeAppVersionAppComponentInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -60,7 +60,7 @@ type DescribeAppVersionAppComponentOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_DescribeAppVersionResource.go b/service/resiliencehub/api_op_DescribeAppVersionResource.go index d050afdb283..67435c182d8 100644 --- a/service/resiliencehub/api_op_DescribeAppVersionResource.go +++ b/service/resiliencehub/api_op_DescribeAppVersionResource.go @@ -42,7 +42,7 @@ type DescribeAppVersionResourceInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -75,7 +75,7 @@ type DescribeAppVersionResourceOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_DescribeAppVersionResourcesResolutionStatus.go b/service/resiliencehub/api_op_DescribeAppVersionResourcesResolutionStatus.go index f3200487ff7..7a22c5accb5 100644 --- a/service/resiliencehub/api_op_DescribeAppVersionResourcesResolutionStatus.go +++ b/service/resiliencehub/api_op_DescribeAppVersionResourcesResolutionStatus.go @@ -39,7 +39,7 @@ type DescribeAppVersionResourcesResolutionStatusInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -60,7 +60,7 @@ type DescribeAppVersionResourcesResolutionStatusOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_DescribeAppVersionTemplate.go b/service/resiliencehub/api_op_DescribeAppVersionTemplate.go index dc632f1c9e3..2c8ab60df98 100644 --- a/service/resiliencehub/api_op_DescribeAppVersionTemplate.go +++ b/service/resiliencehub/api_op_DescribeAppVersionTemplate.go @@ -36,7 +36,7 @@ type DescribeAppVersionTemplateInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -54,7 +54,7 @@ type DescribeAppVersionTemplateOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_DescribeDraftAppVersionResourcesImportStatus.go b/service/resiliencehub/api_op_DescribeDraftAppVersionResourcesImportStatus.go index 77b658e62a1..022ec7cc0d3 100644 --- a/service/resiliencehub/api_op_DescribeDraftAppVersionResourcesImportStatus.go +++ b/service/resiliencehub/api_op_DescribeDraftAppVersionResourcesImportStatus.go @@ -41,7 +41,7 @@ type DescribeDraftAppVersionResourcesImportStatusInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -54,7 +54,7 @@ type DescribeDraftAppVersionResourcesImportStatusOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -69,7 +69,7 @@ type DescribeDraftAppVersionResourcesImportStatusOutput struct { // This member is required. Status types.ResourceImportStatusType - // The timestamp for when the status last changed. + // The time when the status last changed. // // This member is required. StatusChangeTime *time.Time diff --git a/service/resiliencehub/api_op_DescribeResiliencyPolicy.go b/service/resiliencehub/api_op_DescribeResiliencyPolicy.go index 5c1579a1655..54de61ad9c1 100644 --- a/service/resiliencehub/api_op_DescribeResiliencyPolicy.go +++ b/service/resiliencehub/api_op_DescribeResiliencyPolicy.go @@ -39,7 +39,7 @@ type DescribeResiliencyPolicyInput struct { // Amazon Resource Name (ARN) of the resiliency policy. The format for this ARN // is: arn: partition :resiliencehub: region : account :resiliency-policy/ policy-id // . For more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. PolicyArn *string diff --git a/service/resiliencehub/api_op_ImportResourcesToDraftAppVersion.go b/service/resiliencehub/api_op_ImportResourcesToDraftAppVersion.go index 698a2f7a4e8..90b616c04d8 100644 --- a/service/resiliencehub/api_op_ImportResourcesToDraftAppVersion.go +++ b/service/resiliencehub/api_op_ImportResourcesToDraftAppVersion.go @@ -41,7 +41,7 @@ type ImportResourcesToDraftAppVersionInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -68,7 +68,7 @@ type ImportResourcesToDraftAppVersionOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_ListAlarmRecommendations.go b/service/resiliencehub/api_op_ListAlarmRecommendations.go index ee4c804e735..69979c726f8 100644 --- a/service/resiliencehub/api_op_ListAlarmRecommendations.go +++ b/service/resiliencehub/api_op_ListAlarmRecommendations.go @@ -37,7 +37,7 @@ type ListAlarmRecommendationsInput struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string diff --git a/service/resiliencehub/api_op_ListAppAssessmentComplianceDrifts.go b/service/resiliencehub/api_op_ListAppAssessmentComplianceDrifts.go index 47a89df63a2..b9881469bc6 100644 --- a/service/resiliencehub/api_op_ListAppAssessmentComplianceDrifts.go +++ b/service/resiliencehub/api_op_ListAppAssessmentComplianceDrifts.go @@ -37,7 +37,7 @@ type ListAppAssessmentComplianceDriftsInput struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string diff --git a/service/resiliencehub/api_op_ListAppAssessments.go b/service/resiliencehub/api_op_ListAppAssessments.go index 91b4287c586..3569a9ac8fe 100644 --- a/service/resiliencehub/api_op_ListAppAssessments.go +++ b/service/resiliencehub/api_op_ListAppAssessments.go @@ -38,7 +38,7 @@ type ListAppAssessmentsInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. AppArn *string // The name for the assessment. diff --git a/service/resiliencehub/api_op_ListAppComponentCompliances.go b/service/resiliencehub/api_op_ListAppComponentCompliances.go index cbae528a964..a878ee1ce52 100644 --- a/service/resiliencehub/api_op_ListAppComponentCompliances.go +++ b/service/resiliencehub/api_op_ListAppComponentCompliances.go @@ -37,7 +37,7 @@ type ListAppComponentCompliancesInput struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string diff --git a/service/resiliencehub/api_op_ListAppComponentRecommendations.go b/service/resiliencehub/api_op_ListAppComponentRecommendations.go index 2a9eec89d1e..ea65cb27d64 100644 --- a/service/resiliencehub/api_op_ListAppComponentRecommendations.go +++ b/service/resiliencehub/api_op_ListAppComponentRecommendations.go @@ -37,7 +37,7 @@ type ListAppComponentRecommendationsInput struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string diff --git a/service/resiliencehub/api_op_ListAppInputSources.go b/service/resiliencehub/api_op_ListAppInputSources.go index 8e1edb76589..488d4afed90 100644 --- a/service/resiliencehub/api_op_ListAppInputSources.go +++ b/service/resiliencehub/api_op_ListAppInputSources.go @@ -40,7 +40,7 @@ type ListAppInputSourcesInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_ListAppVersionAppComponents.go b/service/resiliencehub/api_op_ListAppVersionAppComponents.go index baa103e8277..944b270367e 100644 --- a/service/resiliencehub/api_op_ListAppVersionAppComponents.go +++ b/service/resiliencehub/api_op_ListAppVersionAppComponents.go @@ -37,7 +37,7 @@ type ListAppVersionAppComponentsInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -62,7 +62,7 @@ type ListAppVersionAppComponentsOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_ListAppVersionResourceMappings.go b/service/resiliencehub/api_op_ListAppVersionResourceMappings.go index 81088c86234..4d64870f636 100644 --- a/service/resiliencehub/api_op_ListAppVersionResourceMappings.go +++ b/service/resiliencehub/api_op_ListAppVersionResourceMappings.go @@ -39,7 +39,7 @@ type ListAppVersionResourceMappingsInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_ListAppVersionResources.go b/service/resiliencehub/api_op_ListAppVersionResources.go index 9f8198c3173..116d80f7631 100644 --- a/service/resiliencehub/api_op_ListAppVersionResources.go +++ b/service/resiliencehub/api_op_ListAppVersionResources.go @@ -37,7 +37,7 @@ type ListAppVersionResourcesInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_ListAppVersions.go b/service/resiliencehub/api_op_ListAppVersions.go index 053123b1a3b..6b32e78a3e5 100644 --- a/service/resiliencehub/api_op_ListAppVersions.go +++ b/service/resiliencehub/api_op_ListAppVersions.go @@ -38,7 +38,7 @@ type ListAppVersionsInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_ListApps.go b/service/resiliencehub/api_op_ListApps.go index b5964c8cac2..8bf4ce2137e 100644 --- a/service/resiliencehub/api_op_ListApps.go +++ b/service/resiliencehub/api_op_ListApps.go @@ -14,6 +14,7 @@ import ( smithyendpoints "github.com/aws/smithy-go/endpoints" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "time" ) // Lists your Resilience Hub applications. You can filter applications using only @@ -41,9 +42,13 @@ type ListAppsInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. AppArn *string + // Indicates the lower limit of the range that is used to filter applications + // based on their last assessment times. + FromLastAssessmentTime *time.Time + // Maximum number of results to include in the response. If more results exist // than the specified MaxResults value, a token is included in the response so // that the remaining results can be retrieved. @@ -55,6 +60,16 @@ type ListAppsInput struct { // Null, or the token from a previous call to get the next set of results. NextToken *string + // The application list is sorted based on the values of + // lastAppComplianceEvaluationTime field. By default, application list is sorted in + // ascending order. To sort the appliation list in descending order, set this field + // to True . + ReverseOrder *bool + + // Indicates the upper limit of the range that is used to filter the applications + // based on their last assessment times. + ToLastAssessmentTime *time.Time + noSmithyDocumentSerde } diff --git a/service/resiliencehub/api_op_ListRecommendationTemplates.go b/service/resiliencehub/api_op_ListRecommendationTemplates.go index 5a68b9d361f..80db590dfba 100644 --- a/service/resiliencehub/api_op_ListRecommendationTemplates.go +++ b/service/resiliencehub/api_op_ListRecommendationTemplates.go @@ -37,7 +37,7 @@ type ListRecommendationTemplatesInput struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string diff --git a/service/resiliencehub/api_op_ListSopRecommendations.go b/service/resiliencehub/api_op_ListSopRecommendations.go index 5d9252de605..a5a99d2eb8a 100644 --- a/service/resiliencehub/api_op_ListSopRecommendations.go +++ b/service/resiliencehub/api_op_ListSopRecommendations.go @@ -38,7 +38,7 @@ type ListSopRecommendationsInput struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string diff --git a/service/resiliencehub/api_op_ListTestRecommendations.go b/service/resiliencehub/api_op_ListTestRecommendations.go index 32ca981b6b4..9fcd1a5c53d 100644 --- a/service/resiliencehub/api_op_ListTestRecommendations.go +++ b/service/resiliencehub/api_op_ListTestRecommendations.go @@ -37,7 +37,7 @@ type ListTestRecommendationsInput struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string diff --git a/service/resiliencehub/api_op_ListUnsupportedAppVersionResources.go b/service/resiliencehub/api_op_ListUnsupportedAppVersionResources.go index c13a318f2b5..3429f130e00 100644 --- a/service/resiliencehub/api_op_ListUnsupportedAppVersionResources.go +++ b/service/resiliencehub/api_op_ListUnsupportedAppVersionResources.go @@ -39,7 +39,7 @@ type ListUnsupportedAppVersionResourcesInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_PublishAppVersion.go b/service/resiliencehub/api_op_PublishAppVersion.go index 62df36a026b..689760ea890 100644 --- a/service/resiliencehub/api_op_PublishAppVersion.go +++ b/service/resiliencehub/api_op_PublishAppVersion.go @@ -36,7 +36,7 @@ type PublishAppVersionInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -52,7 +52,7 @@ type PublishAppVersionOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_PutDraftAppVersionTemplate.go b/service/resiliencehub/api_op_PutDraftAppVersionTemplate.go index 4c476f81d58..3f27a1c7e94 100644 --- a/service/resiliencehub/api_op_PutDraftAppVersionTemplate.go +++ b/service/resiliencehub/api_op_PutDraftAppVersionTemplate.go @@ -37,7 +37,7 @@ type PutDraftAppVersionTemplateInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -126,7 +126,7 @@ type PutDraftAppVersionTemplateOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. AppArn *string // The version of the application. diff --git a/service/resiliencehub/api_op_RemoveDraftAppVersionResourceMappings.go b/service/resiliencehub/api_op_RemoveDraftAppVersionResourceMappings.go index 3880a6ae06b..7a8788311e4 100644 --- a/service/resiliencehub/api_op_RemoveDraftAppVersionResourceMappings.go +++ b/service/resiliencehub/api_op_RemoveDraftAppVersionResourceMappings.go @@ -36,7 +36,7 @@ type RemoveDraftAppVersionResourceMappingsInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -72,7 +72,7 @@ type RemoveDraftAppVersionResourceMappingsOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. AppArn *string // The version of the application. diff --git a/service/resiliencehub/api_op_ResolveAppVersionResources.go b/service/resiliencehub/api_op_ResolveAppVersionResources.go index 83eeee285b2..26a4b72b8fb 100644 --- a/service/resiliencehub/api_op_ResolveAppVersionResources.go +++ b/service/resiliencehub/api_op_ResolveAppVersionResources.go @@ -37,7 +37,7 @@ type ResolveAppVersionResourcesInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -55,7 +55,7 @@ type ResolveAppVersionResourcesOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_StartAppAssessment.go b/service/resiliencehub/api_op_StartAppAssessment.go index 7a8962e223a..9114ba9bbf7 100644 --- a/service/resiliencehub/api_op_StartAppAssessment.go +++ b/service/resiliencehub/api_op_StartAppAssessment.go @@ -37,7 +37,7 @@ type StartAppAssessmentInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_UpdateApp.go b/service/resiliencehub/api_op_UpdateApp.go index fd019cea2d4..2fe0cb75151 100644 --- a/service/resiliencehub/api_op_UpdateApp.go +++ b/service/resiliencehub/api_op_UpdateApp.go @@ -37,7 +37,7 @@ type UpdateAppInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -63,7 +63,7 @@ type UpdateAppInput struct { // Amazon Resource Name (ARN) of the resiliency policy. The format for this ARN // is: arn: partition :resiliencehub: region : account :resiliency-policy/ policy-id // . For more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. PolicyArn *string noSmithyDocumentSerde diff --git a/service/resiliencehub/api_op_UpdateAppVersion.go b/service/resiliencehub/api_op_UpdateAppVersion.go index 1e312e9fc8d..a78968122d5 100644 --- a/service/resiliencehub/api_op_UpdateAppVersion.go +++ b/service/resiliencehub/api_op_UpdateAppVersion.go @@ -39,7 +39,7 @@ type UpdateAppVersionInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -60,7 +60,7 @@ type UpdateAppVersionOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_UpdateAppVersionAppComponent.go b/service/resiliencehub/api_op_UpdateAppVersionAppComponent.go index e71fafe3975..6a71567235e 100644 --- a/service/resiliencehub/api_op_UpdateAppVersionAppComponent.go +++ b/service/resiliencehub/api_op_UpdateAppVersionAppComponent.go @@ -40,7 +40,7 @@ type UpdateAppVersionAppComponentInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -70,7 +70,7 @@ type UpdateAppVersionAppComponentOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_UpdateAppVersionResource.go b/service/resiliencehub/api_op_UpdateAppVersionResource.go index 4267e239948..c887271447c 100644 --- a/service/resiliencehub/api_op_UpdateAppVersionResource.go +++ b/service/resiliencehub/api_op_UpdateAppVersionResource.go @@ -43,7 +43,7 @@ type UpdateAppVersionResourceInput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string @@ -85,7 +85,7 @@ type UpdateAppVersionResourceOutput struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string diff --git a/service/resiliencehub/api_op_UpdateResiliencyPolicy.go b/service/resiliencehub/api_op_UpdateResiliencyPolicy.go index ec61000331f..0e470a75960 100644 --- a/service/resiliencehub/api_op_UpdateResiliencyPolicy.go +++ b/service/resiliencehub/api_op_UpdateResiliencyPolicy.go @@ -16,7 +16,12 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Updates a resiliency policy. +// Updates a resiliency policy. Resilience Hub allows you to provide a value of +// zero for rtoInSecs and rpoInSecs of your resiliency policy. But, while +// assessing your application, the lowest possible assessment result is near zero. +// Hence, if you provide value zero for rtoInSecs and rpoInSecs , the estimated +// workload RTO and estimated workload RPO result will be near zero and the +// Compliance status for your application will be set to Policy breached. func (c *Client) UpdateResiliencyPolicy(ctx context.Context, params *UpdateResiliencyPolicyInput, optFns ...func(*Options)) (*UpdateResiliencyPolicyOutput, error) { if params == nil { params = &UpdateResiliencyPolicyInput{} @@ -37,7 +42,7 @@ type UpdateResiliencyPolicyInput struct { // Amazon Resource Name (ARN) of the resiliency policy. The format for this ARN // is: arn: partition :resiliencehub: region : account :resiliency-policy/ policy-id // . For more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. PolicyArn *string diff --git a/service/resiliencehub/deserializers.go b/service/resiliencehub/deserializers.go index 8e3da7ea34e..8b33651364b 100644 --- a/service/resiliencehub/deserializers.go +++ b/service/resiliencehub/deserializers.go @@ -9985,6 +9985,32 @@ func awsRestjson1_deserializeDocumentApp(v **types.App, value interface{}) error } } + case "rpoInSecs": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.RpoInSecs = ptr.Int32(int32(i64)) + } + + case "rtoInSecs": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.RtoInSecs = ptr.Int32(int32(i64)) + } + case "status": if value != nil { jtv, ok := value.(string) @@ -10821,6 +10847,22 @@ func awsRestjson1_deserializeDocumentAppSummary(v **types.AppSummary, value inte sv.DriftStatus = types.AppDriftStatusType(jtv) } + case "lastAppComplianceEvaluationTime": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.LastAppComplianceEvaluationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value) + + } + } + case "name": if value != nil { jtv, ok := value.(string) @@ -10864,6 +10906,32 @@ func awsRestjson1_deserializeDocumentAppSummary(v **types.AppSummary, value inte } } + case "rpoInSecs": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.RpoInSecs = ptr.Int32(int32(i64)) + } + + case "rtoInSecs": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.RtoInSecs = ptr.Int32(int32(i64)) + } + case "status": if value != nil { jtv, ok := value.(string) diff --git a/service/resiliencehub/endpoints.go b/service/resiliencehub/endpoints.go index 40f2fc3ebe1..d3eb8a7f08d 100644 --- a/service/resiliencehub/endpoints.go +++ b/service/resiliencehub/endpoints.go @@ -410,7 +410,7 @@ func (r *resolver) ResolveEndpoint( } } if _UseFIPS == true { - if true == _PartitionResult.SupportsFIPS { + if _PartitionResult.SupportsFIPS == true { uriString := func() string { var out strings.Builder out.WriteString("https://resiliencehub-fips.") diff --git a/service/resiliencehub/serializers.go b/service/resiliencehub/serializers.go index 4bc5af5afa1..6f73eb18e9a 100644 --- a/service/resiliencehub/serializers.go +++ b/service/resiliencehub/serializers.go @@ -2779,6 +2779,10 @@ func awsRestjson1_serializeOpHttpBindingsListAppsInput(v *ListAppsInput, encoder encoder.SetQuery("appArn").String(*v.AppArn) } + if v.FromLastAssessmentTime != nil { + encoder.SetQuery("fromLastAssessmentTime").String(smithytime.FormatDateTime(*v.FromLastAssessmentTime)) + } + if v.MaxResults != nil { encoder.SetQuery("maxResults").Integer(*v.MaxResults) } @@ -2791,6 +2795,14 @@ func awsRestjson1_serializeOpHttpBindingsListAppsInput(v *ListAppsInput, encoder encoder.SetQuery("nextToken").String(*v.NextToken) } + if v.ReverseOrder != nil { + encoder.SetQuery("reverseOrder").Boolean(*v.ReverseOrder) + } + + if v.ToLastAssessmentTime != nil { + encoder.SetQuery("toLastAssessmentTime").String(smithytime.FormatDateTime(*v.ToLastAssessmentTime)) + } + return nil } diff --git a/service/resiliencehub/types/types.go b/service/resiliencehub/types/types.go index 019fa7c0076..9838877abb4 100644 --- a/service/resiliencehub/types/types.go +++ b/service/resiliencehub/types/types.go @@ -59,12 +59,12 @@ type App struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string - // Timestamp for when the app was created. + // Date and time when the app was created. // // This member is required. CreationTime *time.Time @@ -92,13 +92,13 @@ type App struct { // Scheduled assessment failure events. EventSubscriptions []EventSubscription - // Timestamp for the most recent compliance evaluation. + // Date and time the most recent compliance evaluation. LastAppComplianceEvaluationTime *time.Time // Indicates the last time that a drift was evaluated. LastDriftEvaluationTime *time.Time - // Timestamp for the most recent resiliency score evaluation. + // Date and time the most recent resiliency score evaluation. LastResiliencyScoreEvaluationTime *time.Time // Defines the roles and credentials that Resilience Hub would use while creating @@ -108,12 +108,18 @@ type App struct { // Amazon Resource Name (ARN) of the resiliency policy. The format for this ARN // is: arn: partition :resiliencehub: region : account :resiliency-policy/ policy-id // . For more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. PolicyArn *string // Current resiliency score for the application. ResiliencyScore float64 + // Recovery Point Objective (RPO) in seconds. + RpoInSecs *int32 + + // Recovery Time Objective (RTO) in seconds. + RtoInSecs *int32 + // Status of the application. Status AppStatusType @@ -130,7 +136,7 @@ type AppAssessment struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string @@ -148,7 +154,7 @@ type AppAssessment struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. AppArn *string // Version of an application. @@ -205,7 +211,7 @@ type AppAssessmentSummary struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string @@ -218,7 +224,7 @@ type AppAssessmentSummary struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. AppArn *string // Version of an application. @@ -326,7 +332,7 @@ type AppInputSource struct { // The Amazon Resource Name (ARN) of the input source. For more information about // ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. SourceArn *string // The name of the input source. @@ -344,12 +350,12 @@ type AppSummary struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AppArn *string - // The timestamp for when the app was created. + // Date and time when the app was created. // // This member is required. CreationTime *time.Time @@ -372,9 +378,18 @@ type AppSummary struct { // assessment for your application. DriftStatus AppDriftStatusType + // Date and time of the most recent compliance evaluation. + LastAppComplianceEvaluationTime *time.Time + // The current resiliency score for the application. ResiliencyScore float64 + // Recovery Point Objective (RPO) in seconds. + RpoInSecs *int32 + + // Recovery Time Objective (RTO) in seconds. + RtoInSecs *int32 + // Status of the application. Status AppStatusType @@ -627,7 +642,7 @@ type EksSource struct { // The format for this ARN is: arn: aws :eks: region : account-id :cluster/ // cluster-name . For more information about ARNs, see Amazon Resource Names // (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. EksClusterArn *string @@ -649,7 +664,7 @@ type EksSourceClusterNamespace struct { // The format for this ARN is: arn: aws :eks: region : account-id :cluster/ // cluster-name . For more information about ARNs, see Amazon Resource Names // (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. EksClusterArn *string @@ -682,9 +697,9 @@ type EventSubscription struct { Name *string // Amazon Resource Name (ARN) of the Amazon Simple Notification Service topic. The - // format for this ARN is: arn: partition :resiliencehub: region : account :app/ - // app-id . For more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // format for this ARN is: arn:partition:sns:region:account:topic-name . For more + // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) + // in the Amazon Web Services General Reference guide. SnsTopicArn *string noSmithyDocumentSerde @@ -693,12 +708,12 @@ type EventSubscription struct { // Defines a failure policy. type FailurePolicy struct { - // The Recovery Point Objective (RPO), in seconds. + // Recovery Point Objective (RPO) in seconds. // // This member is required. RpoInSecs int32 - // The Recovery Time Objective (RTO), in seconds. + // Recovery Time Objective (RTO) in seconds. // // This member is required. RtoInSecs int32 @@ -777,7 +792,7 @@ type PhysicalResource struct { // This member is required. PhysicalResourceId *PhysicalResourceId - // The type of resource. + // Type of resource. // // This member is required. ResourceType *string @@ -915,7 +930,7 @@ type RecommendationTemplate struct { // Amazon Resource Name (ARN) of the assessment. The format for this ARN is: arn: // partition :resiliencehub: region : account :app-assessment/ app-id . For more // information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. // // This member is required. AssessmentArn *string @@ -951,7 +966,7 @@ type RecommendationTemplate struct { // Amazon Resource Name (ARN) of the Resilience Hub application. The format for // this ARN is: arn: partition :resiliencehub: region : account :app/ app-id . For // more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. AppArn *string // The end time for the action. @@ -979,10 +994,15 @@ type RecommendationTemplate struct { noSmithyDocumentSerde } -// Defines a resiliency policy. +// Defines a resiliency policy. Resilience Hub allows you to provide a value of +// zero for rtoInSecs and rpoInSecs of your resiliency policy. But, while +// assessing your application, the lowest possible assessment result is near zero. +// Hence, if you provide value zero for rtoInSecs and rpoInSecs , the estimated +// workload RTO and estimated workload RPO result will be near zero and the +// Compliance status for your application will be set to Policy breached. type ResiliencyPolicy struct { - // The timestamp for when the resiliency policy was created. + // Date and time when the resiliency policy was created. CreationTime *time.Time // Specifies a high-level geographical location constraint for where your @@ -998,7 +1018,7 @@ type ResiliencyPolicy struct { // Amazon Resource Name (ARN) of the resiliency policy. The format for this ARN // is: arn: partition :resiliencehub: region : account :resiliency-policy/ policy-id // . For more information about ARNs, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) - // in the AWS General Reference guide. + // in the Amazon Web Services General Reference guide. PolicyArn *string // The description for the policy. diff --git a/service/s3outposts/deserializers.go b/service/s3outposts/deserializers.go index 25edc2256fc..99cdb8abbe9 100644 --- a/service/s3outposts/deserializers.go +++ b/service/s3outposts/deserializers.go @@ -1523,6 +1523,15 @@ func awsRestjson1_deserializeDocumentOutpost(v **types.Outpost, value interface{ sv.OwnerId = ptr.String(jtv) } + case "S3OutpostArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected S3OutpostArn to be of type string, got %T instead", value) + } + sv.S3OutpostArn = ptr.String(jtv) + } + default: _, _ = key, value diff --git a/service/s3outposts/endpoints.go b/service/s3outposts/endpoints.go index 173b7e8e6bd..f2b14e79973 100644 --- a/service/s3outposts/endpoints.go +++ b/service/s3outposts/endpoints.go @@ -410,7 +410,7 @@ func (r *resolver) ResolveEndpoint( } } if _UseFIPS == true { - if true == _PartitionResult.SupportsFIPS { + if _PartitionResult.SupportsFIPS == true { uriString := func() string { var out strings.Builder out.WriteString("https://s3-outposts-fips.") diff --git a/service/s3outposts/types/types.go b/service/s3outposts/types/types.go index 58a197f1319..804e002d484 100644 --- a/service/s3outposts/types/types.go +++ b/service/s3outposts/types/types.go @@ -91,6 +91,10 @@ type Outpost struct { // comparing owned versus shared outposts. OwnerId *string + // Specifies the unique S3 on Outposts ARN for use with Resource Access Manager + // (RAM). + S3OutpostArn *string + noSmithyDocumentSerde } diff --git a/service/wisdom/api_op_CreateAssistant.go b/service/wisdom/api_op_CreateAssistant.go index 16371f35fae..c0ea31a0b6a 100644 --- a/service/wisdom/api_op_CreateAssistant.go +++ b/service/wisdom/api_op_CreateAssistant.go @@ -54,7 +54,15 @@ type CreateAssistantInput struct { // The description of the assistant. Description *string - // The KMS key used for encryption. + // The configuration information for the customer managed key used for encryption. + // The customer managed key must have a policy that allows kms:CreateGrant and + // kms:DescribeKey permissions to the IAM identity using the key to invoke Wisdom. + // To use Wisdom with chat, the key policy must also allow kms:Decrypt , + // kms:GenerateDataKey* , and kms:DescribeKey permissions to the + // connect.amazonaws.com service principal. For more information about setting up a + // customer managed key for Wisdom, see Enable Amazon Connect Wisdom for your + // instance (https://docs.aws.amazon.com/connect/latest/adminguide/enable-wisdom.html) + // . ServerSideEncryptionConfiguration *types.ServerSideEncryptionConfiguration // The tags used to organize, track, or control access for this resource. diff --git a/service/wisdom/api_op_CreateKnowledgeBase.go b/service/wisdom/api_op_CreateKnowledgeBase.go index 7f42bc5a6ad..e818a9af9c2 100644 --- a/service/wisdom/api_op_CreateKnowledgeBase.go +++ b/service/wisdom/api_op_CreateKnowledgeBase.go @@ -72,7 +72,12 @@ type CreateKnowledgeBaseInput struct { // Information about how to render the content. RenderingConfiguration *types.RenderingConfiguration - // The KMS key used for encryption. + // The configuration information for the customer managed key used for encryption. + // This KMS key must have a policy that allows kms:CreateGrant and kms:DescribeKey + // permissions to the IAM identity using the key to invoke Wisdom. For more + // information about setting up a customer managed key for Wisdom, see Enable + // Amazon Connect Wisdom for your instance (https://docs.aws.amazon.com/connect/latest/adminguide/enable-wisdom.html) + // . ServerSideEncryptionConfiguration *types.ServerSideEncryptionConfiguration // The source of the knowledge base content. Only set this argument for EXTERNAL diff --git a/service/wisdom/types/types.go b/service/wisdom/types/types.go index c0b0f288fe0..18d9e6581e4 100644 --- a/service/wisdom/types/types.go +++ b/service/wisdom/types/types.go @@ -28,6 +28,13 @@ type AppIntegrationsConfiguration struct { // - For SharePoint (https://learn.microsoft.com/en-us/sharepoint/dev/sp-add-ins/sharepoint-net-server-csom-jsom-and-rest-api-index) // , your AppIntegrations DataIntegration must have a FileConfiguration, including // only file extensions that are among docx , pdf , html , htm , and txt . + // - For Amazon S3 (https://aws.amazon.com/s3/) , the ObjectConfiguration and + // FileConfiguration of your AppIntegrations DataIntegration must be null. The + // SourceURI of your DataIntegration must use the following format: + // s3://your_s3_bucket_name . The bucket policy of the corresponding S3 bucket + // must allow the Amazon Web Services principal app-integrations.amazonaws.com to + // perform s3:ListBucket , s3:GetObject , and s3:GetBucketLocation against the + // bucket. // // This member is required. AppIntegrationArn *string @@ -198,7 +205,14 @@ type AssistantData struct { // The configuration information for the Wisdom assistant integration. IntegrationConfiguration *AssistantIntegrationConfiguration - // The KMS key used for encryption. + // The configuration information for the customer managed key used for encryption. + // This KMS key must have a policy that allows kms:CreateGrant and kms:DescribeKey + // permissions to the IAM identity using the key to invoke Wisdom. To use Wisdom + // with chat, the key policy must also allow kms:Decrypt , kms:GenerateDataKey* , + // and kms:DescribeKey permissions to the connect.amazonaws.com service principal. + // For more information about setting up a customer managed key for Wisdom, see + // Enable Amazon Connect Wisdom for your instance (https://docs.aws.amazon.com/connect/latest/adminguide/enable-wisdom.html) + // . ServerSideEncryptionConfiguration *ServerSideEncryptionConfiguration // The tags used to organize, track, or control access for this resource. @@ -251,7 +265,14 @@ type AssistantSummary struct { // The configuration information for the Wisdom assistant integration. IntegrationConfiguration *AssistantIntegrationConfiguration - // The KMS key used for encryption. + // The configuration information for the customer managed key used for encryption. + // This KMS key must have a policy that allows kms:CreateGrant and kms:DescribeKey + // permissions to the IAM identity using the key to invoke Wisdom. To use Wisdom + // with chat, the key policy must also allow kms:Decrypt , kms:GenerateDataKey* , + // and kms:DescribeKey permissions to the connect.amazonaws.com service principal. + // For more information about setting up a customer managed key for Wisdom, see + // Enable Amazon Connect Wisdom for your instance (https://docs.aws.amazon.com/connect/latest/adminguide/enable-wisdom.html) + // . ServerSideEncryptionConfiguration *ServerSideEncryptionConfiguration // The tags used to organize, track, or control access for this resource. @@ -528,7 +549,12 @@ type KnowledgeBaseData struct { // Information about how to render the content. RenderingConfiguration *RenderingConfiguration - // The KMS key used for encryption. + // The configuration information for the customer managed key used for encryption. + // This KMS key must have a policy that allows kms:CreateGrant and kms:DescribeKey + // permissions to the IAM identity using the key to invoke Wisdom. For more + // information about setting up a customer managed key for Wisdom, see Enable + // Amazon Connect Wisdom for your instance (https://docs.aws.amazon.com/connect/latest/adminguide/enable-wisdom.html) + // . ServerSideEncryptionConfiguration *ServerSideEncryptionConfiguration // Source configuration information about the knowledge base. @@ -574,7 +600,12 @@ type KnowledgeBaseSummary struct { // Information about how to render the content. RenderingConfiguration *RenderingConfiguration - // The KMS key used for encryption. + // The configuration information for the customer managed key used for encryption. + // This KMS key must have a policy that allows kms:CreateGrant and kms:DescribeKey + // permissions to the IAM identity using the key to invoke Wisdom. For more + // information about setting up a customer managed key for Wisdom, see Enable + // Amazon Connect Wisdom for your instance (https://docs.aws.amazon.com/connect/latest/adminguide/enable-wisdom.html) + // . ServerSideEncryptionConfiguration *ServerSideEncryptionConfiguration // Configuration information about the external data source. @@ -736,10 +767,13 @@ type SearchExpression struct { noSmithyDocumentSerde } -// The KMS key used for encryption. +// The configuration information for the customer managed key used for encryption. type ServerSideEncryptionConfiguration struct { - // The KMS key. For information about valid ID values, see Key identifiers (KeyId) (https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) + // The customer managed key used for encryption. For more information about + // setting up a customer managed key for Wisdom, see Enable Amazon Connect Wisdom + // for your instance (https://docs.aws.amazon.com/connect/latest/adminguide/enable-wisdom.html) + // . For information about valid ID values, see Key identifiers (KeyId) (https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) // . KmsKeyId *string