From 7f1fba9bc8b9ad0850d631cdd03c23c81cae9525 Mon Sep 17 00:00:00 2001 From: AWS SDK for Go v2 automation user Date: Fri, 7 Jul 2023 18:17:38 +0000 Subject: [PATCH] Regenerated Clients --- .../69ae5e84af85408d88f1979a056b4e55.json | 8 + .../6e04fde248cd425e826c004d42659d29.json | 8 + .../b8283e24464a4bed89e20c58844affa6.json | 8 + .../d97905afd3754eafb37fee6bf9a494de.json | 8 + .../eac4600abccc448da001b5566155e18b.json | 8 + .../cloudwatchlogs/api_op_AssociateKmsKey.go | 62 +- .../api_op_DisassociateKmsKey.go | 51 +- .../api_op_GetLogGroupFields.go | 9 +- .../cloudwatchlogs/api_op_GetQueryResults.go | 11 +- .../cloudwatchlogs/api_op_PutAccountPolicy.go | 6 +- .../api_op_PutSubscriptionFilter.go | 5 +- service/cloudwatchlogs/api_op_StartQuery.go | 24 +- service/cloudwatchlogs/deserializers.go | 9 + service/cloudwatchlogs/serializers.go | 10 + service/cloudwatchlogs/validators.go | 42 - .../api_op_CreateEndpoint.go | 3 + .../api_op_CreateReplicationConfig.go | 190 + .../api_op_CreateReplicationInstance.go | 5 +- .../api_op_CreateReplicationSubnetGroup.go | 8 +- .../api_op_DeleteReplicationConfig.go | 129 + .../api_op_DescribeEndpointSettings.go | 2 +- .../api_op_DescribeReplicationConfigs.go | 235 ++ ...i_op_DescribeReplicationTableStatistics.go | 243 ++ .../api_op_DescribeReplications.go | 232 ++ .../api_op_ModifyEndpoint.go | 3 + .../api_op_ModifyReplicationConfig.go | 157 + .../api_op_ReloadReplicationTables.go | 137 + .../api_op_StartReplication.go | 149 + .../api_op_StopReplication.go | 126 + .../databasemigrationservice/deserializers.go | 3635 ++++++++++++++--- .../databasemigrationservice/generated.json | 9 + .../databasemigrationservice/serializers.go | 907 ++++ .../databasemigrationservice/types/enums.go | 39 + .../databasemigrationservice/types/errors.go | 2 +- .../databasemigrationservice/types/types.go | 408 +- .../databasemigrationservice/validators.go | 416 ++ service/glue/api_op_CreateTable.go | 3 + service/glue/serializers.go | 38 + service/glue/types/enums.go | 16 + service/glue/types/types.go | 25 + service/glue/validators.go | 37 + .../api_op_DescribeAccountConfiguration.go | 117 + .../medialive/api_op_DescribeThumbnails.go | 136 + .../api_op_UpdateAccountConfiguration.go | 121 + service/medialive/deserializers.go | 788 +++- service/medialive/generated.json | 3 + service/medialive/serializers.go | 212 + service/medialive/types/enums.go | 36 + service/medialive/types/types.go | 56 + service/medialive/validators.go | 65 + service/mediatailor/deserializers.go | 129 + service/mediatailor/serializers.go | 55 + service/mediatailor/types/enums.go | 18 + service/mediatailor/types/types.go | 30 + service/mediatailor/validators.go | 79 + .../internal/endpoints/endpoints.go | 12 + 56 files changed, 8570 insertions(+), 710 deletions(-) create mode 100644 .changelog/69ae5e84af85408d88f1979a056b4e55.json create mode 100644 .changelog/6e04fde248cd425e826c004d42659d29.json create mode 100644 .changelog/b8283e24464a4bed89e20c58844affa6.json create mode 100644 .changelog/d97905afd3754eafb37fee6bf9a494de.json create mode 100644 .changelog/eac4600abccc448da001b5566155e18b.json create mode 100644 service/databasemigrationservice/api_op_CreateReplicationConfig.go create mode 100644 service/databasemigrationservice/api_op_DeleteReplicationConfig.go create mode 100644 service/databasemigrationservice/api_op_DescribeReplicationConfigs.go create mode 100644 service/databasemigrationservice/api_op_DescribeReplicationTableStatistics.go create mode 100644 service/databasemigrationservice/api_op_DescribeReplications.go create mode 100644 service/databasemigrationservice/api_op_ModifyReplicationConfig.go create mode 100644 service/databasemigrationservice/api_op_ReloadReplicationTables.go create mode 100644 service/databasemigrationservice/api_op_StartReplication.go create mode 100644 service/databasemigrationservice/api_op_StopReplication.go create mode 100644 service/medialive/api_op_DescribeAccountConfiguration.go create mode 100644 service/medialive/api_op_DescribeThumbnails.go create mode 100644 service/medialive/api_op_UpdateAccountConfiguration.go diff --git a/.changelog/69ae5e84af85408d88f1979a056b4e55.json b/.changelog/69ae5e84af85408d88f1979a056b4e55.json new file mode 100644 index 00000000000..b92df6675b1 --- /dev/null +++ b/.changelog/69ae5e84af85408d88f1979a056b4e55.json @@ -0,0 +1,8 @@ +{ + "id": "69ae5e84-af85-408d-88f1-979a056b4e55", + "type": "feature", + "description": "This release enables customers to create new Apache Iceberg tables and associated metadata in Amazon S3 by using native AWS Glue CreateTable operation.", + "modules": [ + "service/glue" + ] +} \ No newline at end of file diff --git a/.changelog/6e04fde248cd425e826c004d42659d29.json b/.changelog/6e04fde248cd425e826c004d42659d29.json new file mode 100644 index 00000000000..eb4100a51c7 --- /dev/null +++ b/.changelog/6e04fde248cd425e826c004d42659d29.json @@ -0,0 +1,8 @@ +{ + "id": "6e04fde2-48cd-425e-826c-004d42659d29", + "type": "feature", + "description": "The AWS Elemental MediaTailor SDK for Channel Assembly has added support for EXT-X-CUE-OUT and EXT-X-CUE-IN tags to specify ad breaks in HLS outputs, including support for EXT-OATCLS, EXT-X-ASSET, and EXT-X-CUE-OUT-CONT accessory tags.", + "modules": [ + "service/mediatailor" + ] +} \ No newline at end of file diff --git a/.changelog/b8283e24464a4bed89e20c58844affa6.json b/.changelog/b8283e24464a4bed89e20c58844affa6.json new file mode 100644 index 00000000000..79568d30ac8 --- /dev/null +++ b/.changelog/b8283e24464a4bed89e20c58844affa6.json @@ -0,0 +1,8 @@ +{ + "id": "b8283e24-464a-4bed-89e2-0c58844affa6", + "type": "feature", + "description": "Add CMK encryption support for CloudWatch Logs Insights query result data", + "modules": [ + "service/cloudwatchlogs" + ] +} \ No newline at end of file diff --git a/.changelog/d97905afd3754eafb37fee6bf9a494de.json b/.changelog/d97905afd3754eafb37fee6bf9a494de.json new file mode 100644 index 00000000000..d31aaaaca02 --- /dev/null +++ b/.changelog/d97905afd3754eafb37fee6bf9a494de.json @@ -0,0 +1,8 @@ +{ + "id": "d97905af-d375-4eaf-b37f-ee6bf9a494de", + "type": "feature", + "description": "Releasing DMS Serverless. Adding support for PostgreSQL 15.x as source and target endpoint. Adding support for DocDB Elastic Clusters with sharded collections, PostgreSQL datatype mapping customization and disabling hostname validation of the certificate authority in Kafka endpoint settings", + "modules": [ + "service/databasemigrationservice" + ] +} \ No newline at end of file diff --git a/.changelog/eac4600abccc448da001b5566155e18b.json b/.changelog/eac4600abccc448da001b5566155e18b.json new file mode 100644 index 00000000000..c273a220392 --- /dev/null +++ b/.changelog/eac4600abccc448da001b5566155e18b.json @@ -0,0 +1,8 @@ +{ + "id": "eac4600a-bccc-448d-a001-b5566155e18b", + "type": "feature", + "description": "This release enables the use of Thumbnails in AWS Elemental MediaLive.", + "modules": [ + "service/medialive" + ] +} \ No newline at end of file diff --git a/service/cloudwatchlogs/api_op_AssociateKmsKey.go b/service/cloudwatchlogs/api_op_AssociateKmsKey.go index 019b43d9c51..df17b43d1ee 100644 --- a/service/cloudwatchlogs/api_op_AssociateKmsKey.go +++ b/service/cloudwatchlogs/api_op_AssociateKmsKey.go @@ -10,15 +10,38 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Associates the specified KMS key with the specified log group. Associating a -// KMS key with a log group overrides any existing associations between the log -// group and a KMS key. After a KMS key is associated with a log group, all newly -// ingested data for the log group is encrypted using the KMS key. This association -// is stored as long as the data encrypted with the KMS keyis still within -// CloudWatch Logs. This enables CloudWatch Logs to decrypt this data whenever it -// is requested. CloudWatch Logs supports only symmetric KMS keys. Do not use an -// associate an asymmetric KMS key with your log group. For more information, see -// Using Symmetric and Asymmetric Keys (https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) +// Associates the specified KMS key with either one log group in the account, or +// with all stored CloudWatch Logs query insights results in the account. When you +// use AssociateKmsKey , you specify either the logGroupName parameter or the +// resourceIdentifier parameter. You can't specify both of those parameters in the +// same operation. +// - Specify the logGroupName parameter to cause all log events stored in the log +// group to be encrypted with that key. Only the log events ingested after the key +// is associated are encrypted with that key. Associating a KMS key with a log +// group overrides any existing associations between the log group and a KMS key. +// After a KMS key is associated with a log group, all newly ingested data for the +// log group is encrypted using the KMS key. This association is stored as long as +// the data encrypted with the KMS key is still within CloudWatch Logs. This +// enables CloudWatch Logs to decrypt this data whenever it is requested. +// Associating a key with a log group does not cause the results of queries of that +// log group to be encrypted with that key. To have query results encrypted with a +// KMS key, you must use an AssociateKmsKey operation with the resourceIdentifier +// parameter that specifies a query-result resource. +// - Specify the resourceIdentifier parameter with a query-result resource, to +// use that key to encrypt the stored results of all future StartQuery (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartQuery.html) +// operations in the account. The response from a GetQueryResults (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetQueryResults.html) +// operation will still return the query results in plain text. Even if you have +// not associated a key with your query results, the query results are encrypted +// when stored, using the default CloudWatch Logs method. If you run a query from a +// monitoring account that queries logs in a source account, the query results key +// from the monitoring account, if any, is used. +// +// If you delete the key that is used to encrypt log events or log group query +// results, then all the associated stored log events or query results that were +// encrypted with that key will be unencryptable and unusable. CloudWatch Logs +// supports only symmetric KMS keys. Do not use an associate an asymmetric KMS key +// with your log group or query results. For more information, see Using Symmetric +// and Asymmetric Keys (https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) // . It can take up to 5 minutes for this operation to take effect. If you attempt // to associate a KMS key with a log group but the KMS key does not exist or the // KMS key is disabled, you receive an InvalidParameterException error. @@ -48,11 +71,26 @@ type AssociateKmsKeyInput struct { // This member is required. KmsKeyId *string - // The name of the log group. - // - // This member is required. + // The name of the log group. In your AssociateKmsKey operation, you must specify + // either the resourceIdentifier parameter or the logGroup parameter, but you + // can't specify both. LogGroupName *string + // Specifies the target for this operation. You must specify one of the following: + // - Specify the following ARN to have future GetQueryResults (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetQueryResults.html) + // operations in this account encrypt the results with the specified KMS key. + // Replace REGION and ACCOUNT_ID with your Region and account ID. + // arn:aws:logs:REGION:ACCOUNT_ID:query-result:* + // - Specify the ARN of a log group to have CloudWatch Logs use the KMS key to + // encrypt log events that are ingested and stored by that log group. The log group + // ARN must be in the following format. Replace REGION and ACCOUNT_ID with your + // Region and account ID. + // arn:aws:logs:REGION:ACCOUNT_ID:log-group:LOG_GROUP_NAME + // In your AssociateKmsKey operation, you must specify either the + // resourceIdentifier parameter or the logGroup parameter, but you can't specify + // both. + ResourceIdentifier *string + noSmithyDocumentSerde } diff --git a/service/cloudwatchlogs/api_op_DisassociateKmsKey.go b/service/cloudwatchlogs/api_op_DisassociateKmsKey.go index 5d461ac225b..f96d28823c2 100644 --- a/service/cloudwatchlogs/api_op_DisassociateKmsKey.go +++ b/service/cloudwatchlogs/api_op_DisassociateKmsKey.go @@ -10,12 +10,26 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) -// Disassociates the associated KMS key from the specified log group. After the -// KMS key is disassociated from the log group, CloudWatch Logs stops encrypting -// newly ingested data for the log group. All previously ingested data remains -// encrypted, and CloudWatch Logs requires permissions for the KMS key whenever the -// encrypted data is requested. Note that it can take up to 5 minutes for this -// operation to take effect. +// Disassociates the specified KMS key from the specified log group or from all +// CloudWatch Logs Insights query results in the account. When you use +// DisassociateKmsKey , you specify either the logGroupName parameter or the +// resourceIdentifier parameter. You can't specify both of those parameters in the +// same operation. +// - Specify the logGroupName parameter to stop using the KMS key to encrypt +// future log events ingested and stored in the log group. Instead, they will be +// encrypted with the default CloudWatch Logs method. The log events that were +// ingested while the key was associated with the log group are still encrypted +// with that key. Therefore, CloudWatch Logs will need permissions for the key +// whenever that data is accessed. +// - Specify the resourceIdentifier parameter with the query-result resource to +// stop using the KMS key to encrypt the results of all future StartQuery (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartQuery.html) +// operations in the account. They will instead be encrypted with the default +// CloudWatch Logs method. The results from queries that ran while the key was +// associated with the account are still encrypted with that key. Therefore, +// CloudWatch Logs will need permissions for the key whenever that data is +// accessed. +// +// It can take up to 5 minutes for this operation to take effect. func (c *Client) DisassociateKmsKey(ctx context.Context, params *DisassociateKmsKeyInput, optFns ...func(*Options)) (*DisassociateKmsKeyOutput, error) { if params == nil { params = &DisassociateKmsKeyInput{} @@ -33,11 +47,27 @@ func (c *Client) DisassociateKmsKey(ctx context.Context, params *DisassociateKms type DisassociateKmsKeyInput struct { - // The name of the log group. - // - // This member is required. + // The name of the log group. In your DisassociateKmsKey operation, you must + // specify either the resourceIdentifier parameter or the logGroup parameter, but + // you can't specify both. LogGroupName *string + // Specifies the target for this operation. You must specify one of the following: + // - Specify the ARN of a log group to stop having CloudWatch Logs use the KMS + // key to encrypt log events that are ingested and stored by that log group. After + // you run this operation, CloudWatch Logs encrypts ingested log events with the + // default CloudWatch Logs method. The log group ARN must be in the following + // format. Replace REGION and ACCOUNT_ID with your Region and account ID. + // arn:aws:logs:REGION:ACCOUNT_ID:log-group:LOG_GROUP_NAME + // - Specify the following ARN to stop using this key to encrypt the results of + // future StartQuery (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartQuery.html) + // operations in this account. Replace REGION and ACCOUNT_ID with your Region and + // account ID. arn:aws:logs:REGION:ACCOUNT_ID:query-result:* + // In your DisssociateKmsKey operation, you must specify either the + // resourceIdentifier parameter or the logGroup parameter, but you can't specify + // both. + ResourceIdentifier *string + noSmithyDocumentSerde } @@ -93,9 +123,6 @@ func (c *Client) addOperationDisassociateKmsKeyMiddlewares(stack *middleware.Sta if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } - if err = addOpDisassociateKmsKeyValidationMiddleware(stack); err != nil { - return err - } if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisassociateKmsKey(options.Region), middleware.Before); err != nil { return err } diff --git a/service/cloudwatchlogs/api_op_GetLogGroupFields.go b/service/cloudwatchlogs/api_op_GetLogGroupFields.go index 1ce98bb184a..0e1fa4564aa 100644 --- a/service/cloudwatchlogs/api_op_GetLogGroupFields.go +++ b/service/cloudwatchlogs/api_op_GetLogGroupFields.go @@ -52,10 +52,11 @@ type GetLogGroupFieldsInput struct { // or logGroupName , but not both. LogGroupName *string - // The time to set as the center of the query. If you specify time , the 15 minutes - // before this time are queries. If you omit time , the 8 minutes before and 8 - // minutes after this time are searched. The time value is specified as epoch - // time, which is the number of seconds since January 1, 1970, 00:00:00 UTC . + // The time to set as the center of the query. If you specify time , the 8 minutes + // before and 8 minutes after this time are searched. If you omit time , the most + // recent 15 minutes up to the current time are searched. The time value is + // specified as epoch time, which is the number of seconds since January 1, 1970, + // 00:00:00 UTC . Time *int64 noSmithyDocumentSerde diff --git a/service/cloudwatchlogs/api_op_GetQueryResults.go b/service/cloudwatchlogs/api_op_GetQueryResults.go index a26469afa88..42e6f058d2d 100644 --- a/service/cloudwatchlogs/api_op_GetQueryResults.go +++ b/service/cloudwatchlogs/api_op_GetQueryResults.go @@ -50,6 +50,12 @@ type GetQueryResultsInput struct { type GetQueryResultsOutput struct { + // If you associated an KMS key with the CloudWatch Logs Insights query results in + // this account, this field displays the ARN of the key that's used to encrypt the + // query results when StartQuery (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartQuery.html) + // stores them. + EncryptionKey *string + // The log events that matched the query criteria during the most recent time it // ran. The results value is an array of arrays. Each log event is one object in // the top-level array. Each of these log event objects is an array of field / value @@ -57,9 +63,8 @@ type GetQueryResultsOutput struct { Results [][]types.ResultField // Includes the number of log events scanned by the query, the number of log - // events that matched the query criteria, and the total number of bytes in the log - // events that were scanned. These values reflect the full raw results of the - // query. + // events that matched the query criteria, and the total number of bytes in the + // scanned log events. These values reflect the full raw results of the query. Statistics *types.QueryStatistics // The status of the most recent running of the query. Possible values are diff --git a/service/cloudwatchlogs/api_op_PutAccountPolicy.go b/service/cloudwatchlogs/api_op_PutAccountPolicy.go index 4e7d9d8d8b8..ca4cd835285 100644 --- a/service/cloudwatchlogs/api_op_PutAccountPolicy.go +++ b/service/cloudwatchlogs/api_op_PutAccountPolicy.go @@ -95,9 +95,9 @@ type PutAccountPolicyInput struct { // This member is required. PolicyType types.PolicyType - // Currently the only valid value for this parameter is GLOBAL , which specifies - // that the data protection policy applies to all log groups in the account. If you - // omit this parameter, the default of GLOBAL is used. + // Currently the only valid value for this parameter is ALL , which specifies that + // the data protection policy applies to all log groups in the account. If you omit + // this parameter, the default of ALL is used. Scope types.Scope noSmithyDocumentSerde diff --git a/service/cloudwatchlogs/api_op_PutSubscriptionFilter.go b/service/cloudwatchlogs/api_op_PutSubscriptionFilter.go index b2b091ea11d..5eb981a288c 100644 --- a/service/cloudwatchlogs/api_op_PutSubscriptionFilter.go +++ b/service/cloudwatchlogs/api_op_PutSubscriptionFilter.go @@ -19,8 +19,9 @@ import ( // format. The following destinations are supported for subscription filters: // - An Amazon Kinesis data stream belonging to the same account as the // subscription filter, for same-account delivery. -// - A logical destination that belongs to a different account, for -// cross-account delivery. +// - A logical destination created with PutDestination (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutDestination.html) +// that belongs to a different account, for cross-account delivery. We currently +// support Kinesis Data Streams and Kinesis Data Firehose as logical destinations. // - An Amazon Kinesis Data Firehose delivery stream that belongs to the same // account as the subscription filter, for same-account delivery. // - An Lambda function that belongs to the same account as the subscription diff --git a/service/cloudwatchlogs/api_op_StartQuery.go b/service/cloudwatchlogs/api_op_StartQuery.go index 049af77f8c7..b6f868a1285 100644 --- a/service/cloudwatchlogs/api_op_StartQuery.go +++ b/service/cloudwatchlogs/api_op_StartQuery.go @@ -13,11 +13,19 @@ import ( // Schedules a query of a log group using CloudWatch Logs Insights. You specify // the log group and time range to query and the query string to use. For more // information, see CloudWatch Logs Insights Query Syntax (https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html) -// . Queries time out after 60 minutes of runtime. If your queries are timing out, -// reduce the time range being searched or partition your query into a number of -// queries. If you are using CloudWatch cross-account observability, you can use -// this operation in a monitoring account to start a query in a linked source -// account. For more information, see CloudWatch cross-account observability (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Unified-Cross-Account.html) +// . After you run a query using StartQuery , the query results are stored by +// CloudWatch Logs. You can use GetQueryResults (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetQueryResults.html) +// to retrieve the results of a query, using the queryId that StartQuery returns. +// If you have associated a KMS key with the query results in this account, then +// StartQuery (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartQuery.html) +// uses that key to encrypt the results when it stores them. If no key is +// associated with query results, the query results are encrypted with the default +// CloudWatch Logs encryption method. Queries time out after 60 minutes of runtime. +// If your queries are timing out, reduce the time range being searched or +// partition your query into a number of queries. If you are using CloudWatch +// cross-account observability, you can use this operation in a monitoring account +// to start a query in a linked source account. For more information, see +// CloudWatch cross-account observability (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Unified-Cross-Account.html) // . For a cross-account StartQuery operation, the query definition must be // defined in the monitoring account. You can have up to 30 concurrent CloudWatch // Logs insights queries, including queries that have been added to dashboards. @@ -70,17 +78,17 @@ type StartQueryInput struct { // the ARN of the log group here. The query definition must also be defined in the // monitoring account. If you specify an ARN, the ARN can't end with an asterisk // (*). A StartQuery operation must include exactly one of the following - // parameters: logGroupName , logGroupNames or logGroupIdentifiers . + // parameters: logGroupName , logGroupNames , or logGroupIdentifiers . LogGroupIdentifiers []string // The log group on which to perform the query. A StartQuery operation must - // include exactly one of the following parameters: logGroupName , logGroupNames + // include exactly one of the following parameters: logGroupName , logGroupNames , // or logGroupIdentifiers . LogGroupName *string // The list of log groups to be queried. You can include up to 50 log groups. A // StartQuery operation must include exactly one of the following parameters: - // logGroupName , logGroupNames or logGroupIdentifiers . + // logGroupName , logGroupNames , or logGroupIdentifiers . LogGroupNames []string noSmithyDocumentSerde diff --git a/service/cloudwatchlogs/deserializers.go b/service/cloudwatchlogs/deserializers.go index 9f0f0e3ae88..d6a8b7ffd04 100644 --- a/service/cloudwatchlogs/deserializers.go +++ b/service/cloudwatchlogs/deserializers.go @@ -9925,6 +9925,15 @@ func awsAwsjson11_deserializeOpDocumentGetQueryResultsOutput(v **GetQueryResults for key, value := range shape { switch key { + case "encryptionKey": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected EncryptionKey to be of type string, got %T instead", value) + } + sv.EncryptionKey = ptr.String(jtv) + } + case "results": if err := awsAwsjson11_deserializeDocumentQueryResults(&sv.Results, value); err != nil { return err diff --git a/service/cloudwatchlogs/serializers.go b/service/cloudwatchlogs/serializers.go index 2193386cc17..e81f65bc7f2 100644 --- a/service/cloudwatchlogs/serializers.go +++ b/service/cloudwatchlogs/serializers.go @@ -3028,6 +3028,11 @@ func awsAwsjson11_serializeOpDocumentAssociateKmsKeyInput(v *AssociateKmsKeyInpu ok.String(*v.LogGroupName) } + if v.ResourceIdentifier != nil { + ok := object.Key("resourceIdentifier") + ok.String(*v.ResourceIdentifier) + } + return nil } @@ -3559,6 +3564,11 @@ func awsAwsjson11_serializeOpDocumentDisassociateKmsKeyInput(v *DisassociateKmsK ok.String(*v.LogGroupName) } + if v.ResourceIdentifier != nil { + ok := object.Key("resourceIdentifier") + ok.String(*v.ResourceIdentifier) + } + return nil } diff --git a/service/cloudwatchlogs/validators.go b/service/cloudwatchlogs/validators.go index e2768d51976..75c285825e5 100644 --- a/service/cloudwatchlogs/validators.go +++ b/service/cloudwatchlogs/validators.go @@ -330,26 +330,6 @@ func (m *validateOpDescribeSubscriptionFilters) HandleInitialize(ctx context.Con return next.HandleInitialize(ctx, in) } -type validateOpDisassociateKmsKey struct { -} - -func (*validateOpDisassociateKmsKey) ID() string { - return "OperationInputValidation" -} - -func (m *validateOpDisassociateKmsKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( - out middleware.InitializeOutput, metadata middleware.Metadata, err error, -) { - input, ok := in.Parameters.(*DisassociateKmsKeyInput) - if !ok { - return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) - } - if err := validateOpDisassociateKmsKeyInput(input); err != nil { - return out, metadata, err - } - return next.HandleInitialize(ctx, in) -} - type validateOpGetDataProtectionPolicy struct { } @@ -854,10 +834,6 @@ func addOpDescribeSubscriptionFiltersValidationMiddleware(stack *middleware.Stac return stack.Initialize.Add(&validateOpDescribeSubscriptionFilters{}, middleware.After) } -func addOpDisassociateKmsKeyValidationMiddleware(stack *middleware.Stack) error { - return stack.Initialize.Add(&validateOpDisassociateKmsKey{}, middleware.After) -} - func addOpGetDataProtectionPolicyValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpGetDataProtectionPolicy{}, middleware.After) } @@ -1024,9 +1000,6 @@ func validateOpAssociateKmsKeyInput(v *AssociateKmsKeyInput) error { return nil } invalidParams := smithy.InvalidParamsError{Context: "AssociateKmsKeyInput"} - if v.LogGroupName == nil { - invalidParams.Add(smithy.NewErrParamRequired("LogGroupName")) - } if v.KmsKeyId == nil { invalidParams.Add(smithy.NewErrParamRequired("KmsKeyId")) } @@ -1286,21 +1259,6 @@ func validateOpDescribeSubscriptionFiltersInput(v *DescribeSubscriptionFiltersIn } } -func validateOpDisassociateKmsKeyInput(v *DisassociateKmsKeyInput) error { - if v == nil { - return nil - } - invalidParams := smithy.InvalidParamsError{Context: "DisassociateKmsKeyInput"} - if v.LogGroupName == nil { - invalidParams.Add(smithy.NewErrParamRequired("LogGroupName")) - } - if invalidParams.Len() > 0 { - return invalidParams - } else { - return nil - } -} - func validateOpGetDataProtectionPolicyInput(v *GetDataProtectionPolicyInput) error { if v == nil { return nil diff --git a/service/databasemigrationservice/api_op_CreateEndpoint.go b/service/databasemigrationservice/api_op_CreateEndpoint.go index 31b62e440d1..2fb01ed9f5f 100644 --- a/service/databasemigrationservice/api_op_CreateEndpoint.go +++ b/service/databasemigrationservice/api_op_CreateEndpoint.go @@ -218,6 +218,9 @@ type CreateEndpointInput struct { // One or more tags to be assigned to the endpoint. Tags []types.Tag + // Settings in JSON format for the target Amazon Timestream endpoint. + TimestreamSettings *types.TimestreamSettings + // The user name to be used to log in to the endpoint database. Username *string diff --git a/service/databasemigrationservice/api_op_CreateReplicationConfig.go b/service/databasemigrationservice/api_op_CreateReplicationConfig.go new file mode 100644 index 00000000000..da71ac71864 --- /dev/null +++ b/service/databasemigrationservice/api_op_CreateReplicationConfig.go @@ -0,0 +1,190 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package databasemigrationservice + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/databasemigrationservice/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Creates a configuration that you can later provide to configure and start an +// DMS Serverless replication. You can also provide options to validate the +// configuration inputs before you start the replication. +func (c *Client) CreateReplicationConfig(ctx context.Context, params *CreateReplicationConfigInput, optFns ...func(*Options)) (*CreateReplicationConfigOutput, error) { + if params == nil { + params = &CreateReplicationConfigInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateReplicationConfig", params, optFns, c.addOperationCreateReplicationConfigMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateReplicationConfigOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateReplicationConfigInput struct { + + // Configuration parameters for provisioning an DMS Serverless replication. + // + // This member is required. + ComputeConfig *types.ComputeConfig + + // A unique identifier that you want to use to create a ReplicationConfigArn that + // is returned as part of the output from this action. You can then pass this + // output ReplicationConfigArn as the value of the ReplicationConfigArn option for + // other actions to identify both DMS Serverless replications and replication + // configurations that you want those actions to operate on. For some actions, you + // can also use either this unique identifier or a corresponding ARN in action + // filters to identify the specific replication and replication configuration to + // operate on. + // + // This member is required. + ReplicationConfigIdentifier *string + + // The type of DMS Serverless replication to provision using this replication + // configuration. Possible values: + // - "full-load" + // - "cdc" + // - "full-load-and-cdc" + // + // This member is required. + ReplicationType types.MigrationTypeValue + + // The Amazon Resource Name (ARN) of the source endpoint for this DMS Serverless + // replication configuration. + // + // This member is required. + SourceEndpointArn *string + + // JSON table mappings for DMS Serverless replications that are provisioned using + // this replication configuration. For more information, see Specifying table + // selection and transformations rules using JSON (https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.html) + // . + // + // This member is required. + TableMappings *string + + // The Amazon Resource Name (ARN) of the target endpoint for this DMS serverless + // replication configuration. + // + // This member is required. + TargetEndpointArn *string + + // Optional JSON settings for DMS Serverless replications that are provisioned + // using this replication configuration. For example, see Change processing tuning + // settings (https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TaskSettings.ChangeProcessingTuning.html) + // . + ReplicationSettings *string + + // Optional unique value or name that you set for a given resource that can be + // used to construct an Amazon Resource Name (ARN) for that resource. For more + // information, see Fine-grained access control using resource names and tags (https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Security.html#CHAP_Security.FineGrainedAccess) + // . + ResourceIdentifier *string + + // Optional JSON settings for specifying supplemental data. For more information, + // see Specifying supplemental data for task settings (https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.TaskData.html) + // . + SupplementalSettings *string + + // One or more optional tags associated with resources used by the DMS Serverless + // replication. For more information, see Tagging resources in Database Migration + // Service (https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tagging.html) . + Tags []types.Tag + + noSmithyDocumentSerde +} + +type CreateReplicationConfigOutput struct { + + // Configuration parameters returned from the DMS Serverless replication after it + // is created. + ReplicationConfig *types.ReplicationConfig + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationCreateReplicationConfigMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateReplicationConfig{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateReplicationConfig{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpCreateReplicationConfigValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateReplicationConfig(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 + } + return nil +} + +func newServiceMetadataMiddleware_opCreateReplicationConfig(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "dms", + OperationName: "CreateReplicationConfig", + } +} diff --git a/service/databasemigrationservice/api_op_CreateReplicationInstance.go b/service/databasemigrationservice/api_op_CreateReplicationInstance.go index 8d85eaa0427..0fae6e99458 100644 --- a/service/databasemigrationservice/api_op_CreateReplicationInstance.go +++ b/service/databasemigrationservice/api_op_CreateReplicationInstance.go @@ -39,7 +39,8 @@ type CreateReplicationInstanceInput struct { // specified replication instance class. For example to specify the instance class // dms.c4.large, set this parameter to "dms.c4.large" . For more information on the // settings and capacities for the available replication instance classes, see - // Selecting the right DMS replication instance for your migration (https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.html#CHAP_ReplicationInstance.InDepth) + // Choosing the right DMS replication instance (https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.Types.html) + // ; and, Selecting the best size for a replication instance (https://docs.aws.amazon.com/dms/latest/userguide/CHAP_BestPractices.SizingReplicationInstance.html) // . // // This member is required. @@ -71,7 +72,7 @@ type CreateReplicationInstanceInput struct { // The Availability Zone where the replication instance will be created. The // default value is a random, system-chosen Availability Zone in the endpoint's - // Amazon Web Services Region, for example: us-east-1d + // Amazon Web Services Region, for example: us-east-1d . AvailabilityZone *string // A list of custom DNS name servers supported for the replication instance to diff --git a/service/databasemigrationservice/api_op_CreateReplicationSubnetGroup.go b/service/databasemigrationservice/api_op_CreateReplicationSubnetGroup.go index 8b4648ae93a..434f59b57d6 100644 --- a/service/databasemigrationservice/api_op_CreateReplicationSubnetGroup.go +++ b/service/databasemigrationservice/api_op_CreateReplicationSubnetGroup.go @@ -14,7 +14,13 @@ import ( // Creates a replication subnet group given a list of the subnet IDs in a VPC. The // VPC needs to have at least one subnet in at least two availability zones in the // Amazon Web Services Region, otherwise the service will throw a -// ReplicationSubnetGroupDoesNotCoverEnoughAZs exception. +// ReplicationSubnetGroupDoesNotCoverEnoughAZs exception. If a replication subnet +// group exists in your Amazon Web Services account, the +// CreateReplicationSubnetGroup action returns the following error message: The +// Replication Subnet Group already exists. In this case, delete the existing +// replication subnet group. To do so, use the DeleteReplicationSubnetGroup (https://docs.aws.amazon.com/en_us/dms/latest/APIReference/API_DeleteReplicationSubnetGroup.html) +// action. Optionally, choose Subnet groups in the DMS console, then choose your +// subnet group. Next, choose Delete from Actions. func (c *Client) CreateReplicationSubnetGroup(ctx context.Context, params *CreateReplicationSubnetGroupInput, optFns ...func(*Options)) (*CreateReplicationSubnetGroupOutput, error) { if params == nil { params = &CreateReplicationSubnetGroupInput{} diff --git a/service/databasemigrationservice/api_op_DeleteReplicationConfig.go b/service/databasemigrationservice/api_op_DeleteReplicationConfig.go new file mode 100644 index 00000000000..e808d106535 --- /dev/null +++ b/service/databasemigrationservice/api_op_DeleteReplicationConfig.go @@ -0,0 +1,129 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package databasemigrationservice + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/databasemigrationservice/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Deletes an DMS Serverless replication configuration. This effectively +// deprovisions any and all replications that use this configuration. You can't +// delete the configuration for an DMS Serverless replication that is ongoing. You +// can delete the configuration when the replication is in a non-RUNNING and +// non-STARTING state. +func (c *Client) DeleteReplicationConfig(ctx context.Context, params *DeleteReplicationConfigInput, optFns ...func(*Options)) (*DeleteReplicationConfigOutput, error) { + if params == nil { + params = &DeleteReplicationConfigInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteReplicationConfig", params, optFns, c.addOperationDeleteReplicationConfigMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteReplicationConfigOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteReplicationConfigInput struct { + + // The replication config to delete. + // + // This member is required. + ReplicationConfigArn *string + + noSmithyDocumentSerde +} + +type DeleteReplicationConfigOutput struct { + + // Configuration parameters returned for the DMS Serverless replication after it + // is deleted. + ReplicationConfig *types.ReplicationConfig + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDeleteReplicationConfigMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteReplicationConfig{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteReplicationConfig{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpDeleteReplicationConfigValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteReplicationConfig(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 + } + return nil +} + +func newServiceMetadataMiddleware_opDeleteReplicationConfig(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "dms", + OperationName: "DeleteReplicationConfig", + } +} diff --git a/service/databasemigrationservice/api_op_DescribeEndpointSettings.go b/service/databasemigrationservice/api_op_DescribeEndpointSettings.go index 690d206646a..f27047db771 100644 --- a/service/databasemigrationservice/api_op_DescribeEndpointSettings.go +++ b/service/databasemigrationservice/api_op_DescribeEndpointSettings.go @@ -31,7 +31,7 @@ func (c *Client) DescribeEndpointSettings(ctx context.Context, params *DescribeE type DescribeEndpointSettingsInput struct { - // The databse engine used for your source or target endpoint. + // The database engine used for your source or target endpoint. // // This member is required. EngineName *string diff --git a/service/databasemigrationservice/api_op_DescribeReplicationConfigs.go b/service/databasemigrationservice/api_op_DescribeReplicationConfigs.go new file mode 100644 index 00000000000..b14ce35e44f --- /dev/null +++ b/service/databasemigrationservice/api_op_DescribeReplicationConfigs.go @@ -0,0 +1,235 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package databasemigrationservice + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/databasemigrationservice/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Returns one or more existing DMS Serverless replication configurations as a +// list of structures. +func (c *Client) DescribeReplicationConfigs(ctx context.Context, params *DescribeReplicationConfigsInput, optFns ...func(*Options)) (*DescribeReplicationConfigsOutput, error) { + if params == nil { + params = &DescribeReplicationConfigsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeReplicationConfigs", params, optFns, c.addOperationDescribeReplicationConfigsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeReplicationConfigsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeReplicationConfigsInput struct { + + // Filters applied to the replication configs. + Filters []types.Filter + + // An optional pagination token provided by a previous 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 the remaining results can be retrieved. + MaxRecords *int32 + + noSmithyDocumentSerde +} + +type DescribeReplicationConfigsOutput struct { + + // An optional pagination token provided by a previous request. If this parameter + // is specified, the response includes only records beyond the marker, up to the + // value specified by MaxRecords . + Marker *string + + // Returned configuration parameters that describe each provisioned DMS Serverless + // replication. + ReplicationConfigs []types.ReplicationConfig + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeReplicationConfigsMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeReplicationConfigs{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeReplicationConfigs{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpDescribeReplicationConfigsValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeReplicationConfigs(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 + } + return nil +} + +// DescribeReplicationConfigsAPIClient is a client that implements the +// DescribeReplicationConfigs operation. +type DescribeReplicationConfigsAPIClient interface { + DescribeReplicationConfigs(context.Context, *DescribeReplicationConfigsInput, ...func(*Options)) (*DescribeReplicationConfigsOutput, error) +} + +var _ DescribeReplicationConfigsAPIClient = (*Client)(nil) + +// DescribeReplicationConfigsPaginatorOptions is the paginator options for +// DescribeReplicationConfigs +type DescribeReplicationConfigsPaginatorOptions 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 the remaining results can be retrieved. + 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 +} + +// DescribeReplicationConfigsPaginator is a paginator for +// DescribeReplicationConfigs +type DescribeReplicationConfigsPaginator struct { + options DescribeReplicationConfigsPaginatorOptions + client DescribeReplicationConfigsAPIClient + params *DescribeReplicationConfigsInput + nextToken *string + firstPage bool +} + +// NewDescribeReplicationConfigsPaginator returns a new +// DescribeReplicationConfigsPaginator +func NewDescribeReplicationConfigsPaginator(client DescribeReplicationConfigsAPIClient, params *DescribeReplicationConfigsInput, optFns ...func(*DescribeReplicationConfigsPaginatorOptions)) *DescribeReplicationConfigsPaginator { + if params == nil { + params = &DescribeReplicationConfigsInput{} + } + + options := DescribeReplicationConfigsPaginatorOptions{} + if params.MaxRecords != nil { + options.Limit = *params.MaxRecords + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeReplicationConfigsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.Marker, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeReplicationConfigsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeReplicationConfigs page. +func (p *DescribeReplicationConfigsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeReplicationConfigsOutput, 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.DescribeReplicationConfigs(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_opDescribeReplicationConfigs(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "dms", + OperationName: "DescribeReplicationConfigs", + } +} diff --git a/service/databasemigrationservice/api_op_DescribeReplicationTableStatistics.go b/service/databasemigrationservice/api_op_DescribeReplicationTableStatistics.go new file mode 100644 index 00000000000..83afbd21be2 --- /dev/null +++ b/service/databasemigrationservice/api_op_DescribeReplicationTableStatistics.go @@ -0,0 +1,243 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package databasemigrationservice + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/databasemigrationservice/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Returns table and schema statistics for one or more provisioned replications +// that use a given DMS Serverless replication configuration. +func (c *Client) DescribeReplicationTableStatistics(ctx context.Context, params *DescribeReplicationTableStatisticsInput, optFns ...func(*Options)) (*DescribeReplicationTableStatisticsOutput, error) { + if params == nil { + params = &DescribeReplicationTableStatisticsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeReplicationTableStatistics", params, optFns, c.addOperationDescribeReplicationTableStatisticsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeReplicationTableStatisticsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeReplicationTableStatisticsInput struct { + + // The replication config to describe. + // + // This member is required. + ReplicationConfigArn *string + + // Filters applied to the replication table statistics. + Filters []types.Filter + + // An optional pagination token provided by a previous 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 the remaining results can be retrieved. + MaxRecords *int32 + + noSmithyDocumentSerde +} + +type DescribeReplicationTableStatisticsOutput struct { + + // An optional pagination token provided by a previous request. If this parameter + // is specified, the response includes only records beyond the marker, up to the + // value specified by MaxRecords . + Marker *string + + // The Amazon Resource Name of the replication config. + ReplicationConfigArn *string + + // Returns table statistics on the replication, including table name, rows + // inserted, rows updated, and rows deleted. + ReplicationTableStatistics []types.TableStatistics + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeReplicationTableStatisticsMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeReplicationTableStatistics{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeReplicationTableStatistics{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpDescribeReplicationTableStatisticsValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeReplicationTableStatistics(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 + } + return nil +} + +// DescribeReplicationTableStatisticsAPIClient is a client that implements the +// DescribeReplicationTableStatistics operation. +type DescribeReplicationTableStatisticsAPIClient interface { + DescribeReplicationTableStatistics(context.Context, *DescribeReplicationTableStatisticsInput, ...func(*Options)) (*DescribeReplicationTableStatisticsOutput, error) +} + +var _ DescribeReplicationTableStatisticsAPIClient = (*Client)(nil) + +// DescribeReplicationTableStatisticsPaginatorOptions is the paginator options for +// DescribeReplicationTableStatistics +type DescribeReplicationTableStatisticsPaginatorOptions 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 the remaining results can be retrieved. + 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 +} + +// DescribeReplicationTableStatisticsPaginator is a paginator for +// DescribeReplicationTableStatistics +type DescribeReplicationTableStatisticsPaginator struct { + options DescribeReplicationTableStatisticsPaginatorOptions + client DescribeReplicationTableStatisticsAPIClient + params *DescribeReplicationTableStatisticsInput + nextToken *string + firstPage bool +} + +// NewDescribeReplicationTableStatisticsPaginator returns a new +// DescribeReplicationTableStatisticsPaginator +func NewDescribeReplicationTableStatisticsPaginator(client DescribeReplicationTableStatisticsAPIClient, params *DescribeReplicationTableStatisticsInput, optFns ...func(*DescribeReplicationTableStatisticsPaginatorOptions)) *DescribeReplicationTableStatisticsPaginator { + if params == nil { + params = &DescribeReplicationTableStatisticsInput{} + } + + options := DescribeReplicationTableStatisticsPaginatorOptions{} + if params.MaxRecords != nil { + options.Limit = *params.MaxRecords + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeReplicationTableStatisticsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.Marker, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeReplicationTableStatisticsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeReplicationTableStatistics page. +func (p *DescribeReplicationTableStatisticsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeReplicationTableStatisticsOutput, 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.DescribeReplicationTableStatistics(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_opDescribeReplicationTableStatistics(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "dms", + OperationName: "DescribeReplicationTableStatistics", + } +} diff --git a/service/databasemigrationservice/api_op_DescribeReplications.go b/service/databasemigrationservice/api_op_DescribeReplications.go new file mode 100644 index 00000000000..90f60165e1e --- /dev/null +++ b/service/databasemigrationservice/api_op_DescribeReplications.go @@ -0,0 +1,232 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package databasemigrationservice + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/databasemigrationservice/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Provides details on replication progress by returning status information for +// one or more provisioned DMS Serverless replications. +func (c *Client) DescribeReplications(ctx context.Context, params *DescribeReplicationsInput, optFns ...func(*Options)) (*DescribeReplicationsOutput, error) { + if params == nil { + params = &DescribeReplicationsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeReplications", params, optFns, c.addOperationDescribeReplicationsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeReplicationsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeReplicationsInput struct { + + // Filters applied to the replications. + Filters []types.Filter + + // An optional pagination token provided by a previous 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 the remaining results can be retrieved. + MaxRecords *int32 + + noSmithyDocumentSerde +} + +type DescribeReplicationsOutput struct { + + // An optional pagination token provided by a previous request. If this parameter + // is specified, the response includes only records beyond the marker, up to the + // value specified by MaxRecords . + Marker *string + + // The replication descriptions. + Replications []types.Replication + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeReplicationsMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeReplications{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeReplications{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpDescribeReplicationsValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeReplications(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 + } + return nil +} + +// DescribeReplicationsAPIClient is a client that implements the +// DescribeReplications operation. +type DescribeReplicationsAPIClient interface { + DescribeReplications(context.Context, *DescribeReplicationsInput, ...func(*Options)) (*DescribeReplicationsOutput, error) +} + +var _ DescribeReplicationsAPIClient = (*Client)(nil) + +// DescribeReplicationsPaginatorOptions is the paginator options for +// DescribeReplications +type DescribeReplicationsPaginatorOptions 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 the remaining results can be retrieved. + 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 +} + +// DescribeReplicationsPaginator is a paginator for DescribeReplications +type DescribeReplicationsPaginator struct { + options DescribeReplicationsPaginatorOptions + client DescribeReplicationsAPIClient + params *DescribeReplicationsInput + nextToken *string + firstPage bool +} + +// NewDescribeReplicationsPaginator returns a new DescribeReplicationsPaginator +func NewDescribeReplicationsPaginator(client DescribeReplicationsAPIClient, params *DescribeReplicationsInput, optFns ...func(*DescribeReplicationsPaginatorOptions)) *DescribeReplicationsPaginator { + if params == nil { + params = &DescribeReplicationsInput{} + } + + options := DescribeReplicationsPaginatorOptions{} + if params.MaxRecords != nil { + options.Limit = *params.MaxRecords + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeReplicationsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.Marker, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeReplicationsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeReplications page. +func (p *DescribeReplicationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeReplicationsOutput, 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.DescribeReplications(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_opDescribeReplications(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "dms", + OperationName: "DescribeReplications", + } +} diff --git a/service/databasemigrationservice/api_op_ModifyEndpoint.go b/service/databasemigrationservice/api_op_ModifyEndpoint.go index 56778bbb3ae..c2d427411c6 100644 --- a/service/databasemigrationservice/api_op_ModifyEndpoint.go +++ b/service/databasemigrationservice/api_op_ModifyEndpoint.go @@ -212,6 +212,9 @@ type ModifyEndpointInput struct { // in the Database Migration Service User Guide. SybaseSettings *types.SybaseSettings + // Settings in JSON format for the target Amazon Timestream endpoint. + TimestreamSettings *types.TimestreamSettings + // The user name to be used to login to the endpoint database. Username *string diff --git a/service/databasemigrationservice/api_op_ModifyReplicationConfig.go b/service/databasemigrationservice/api_op_ModifyReplicationConfig.go new file mode 100644 index 00000000000..7014b26a439 --- /dev/null +++ b/service/databasemigrationservice/api_op_ModifyReplicationConfig.go @@ -0,0 +1,157 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package databasemigrationservice + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/databasemigrationservice/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Modifies an existing DMS Serverless replication configuration that you can use +// to start a replication. This command includes input validation and logic to +// check the state of any replication that uses this configuration. You can only +// modify a replication configuration before any replication that uses it has +// started. As soon as you have initially started a replication with a given +// configuiration, you can't modify that configuration, even if you stop it. Other +// run statuses that allow you to run this command include FAILED and CREATED. A +// provisioning state that allows you to run this command is FAILED_PROVISION. +func (c *Client) ModifyReplicationConfig(ctx context.Context, params *ModifyReplicationConfigInput, optFns ...func(*Options)) (*ModifyReplicationConfigOutput, error) { + if params == nil { + params = &ModifyReplicationConfigInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ModifyReplicationConfig", params, optFns, c.addOperationModifyReplicationConfigMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ModifyReplicationConfigOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ModifyReplicationConfigInput struct { + + // The Amazon Resource Name of the replication to modify. + // + // This member is required. + ReplicationConfigArn *string + + // Configuration parameters for provisioning an DMS Serverless replication. + ComputeConfig *types.ComputeConfig + + // The new replication config to apply to the replication. + ReplicationConfigIdentifier *string + + // The settings for the replication. + ReplicationSettings *string + + // The type of replication. + ReplicationType types.MigrationTypeValue + + // The Amazon Resource Name (ARN) of the source endpoint for this DMS serverless + // replication configuration. + SourceEndpointArn *string + + // Additional settings for the replication. + SupplementalSettings *string + + // Table mappings specified in the replication. + TableMappings *string + + // The Amazon Resource Name (ARN) of the target endpoint for this DMS serverless + // replication configuration. + TargetEndpointArn *string + + noSmithyDocumentSerde +} + +type ModifyReplicationConfigOutput struct { + + // Information about the serverless replication config that was modified. + ReplicationConfig *types.ReplicationConfig + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationModifyReplicationConfigMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpModifyReplicationConfig{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpModifyReplicationConfig{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpModifyReplicationConfigValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opModifyReplicationConfig(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 + } + return nil +} + +func newServiceMetadataMiddleware_opModifyReplicationConfig(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "dms", + OperationName: "ModifyReplicationConfig", + } +} diff --git a/service/databasemigrationservice/api_op_ReloadReplicationTables.go b/service/databasemigrationservice/api_op_ReloadReplicationTables.go new file mode 100644 index 00000000000..48fa8aad3de --- /dev/null +++ b/service/databasemigrationservice/api_op_ReloadReplicationTables.go @@ -0,0 +1,137 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package databasemigrationservice + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/databasemigrationservice/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Reloads the target database table with the source data for a given DMS +// Serverless replication configuration. You can only use this operation with a +// task in the RUNNING state, otherwise the service will throw an +// InvalidResourceStateFault exception. +func (c *Client) ReloadReplicationTables(ctx context.Context, params *ReloadReplicationTablesInput, optFns ...func(*Options)) (*ReloadReplicationTablesOutput, error) { + if params == nil { + params = &ReloadReplicationTablesInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ReloadReplicationTables", params, optFns, c.addOperationReloadReplicationTablesMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ReloadReplicationTablesOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ReloadReplicationTablesInput struct { + + // The Amazon Resource Name of the replication config for which to reload tables. + // + // This member is required. + ReplicationConfigArn *string + + // The list of tables to reload. + // + // This member is required. + TablesToReload []types.TableToReload + + // Options for reload. Specify data-reload to reload the data and re-validate it + // if validation is enabled. Specify validate-only to re-validate the table. This + // option applies only when validation is enabled for the replication. + ReloadOption types.ReloadOptionValue + + noSmithyDocumentSerde +} + +type ReloadReplicationTablesOutput struct { + + // The Amazon Resource Name of the replication config for which to reload tables. + ReplicationConfigArn *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationReloadReplicationTablesMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpReloadReplicationTables{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpReloadReplicationTables{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpReloadReplicationTablesValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opReloadReplicationTables(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 + } + return nil +} + +func newServiceMetadataMiddleware_opReloadReplicationTables(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "dms", + OperationName: "ReloadReplicationTables", + } +} diff --git a/service/databasemigrationservice/api_op_StartReplication.go b/service/databasemigrationservice/api_op_StartReplication.go new file mode 100644 index 00000000000..1803a86aa4b --- /dev/null +++ b/service/databasemigrationservice/api_op_StartReplication.go @@ -0,0 +1,149 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package databasemigrationservice + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/databasemigrationservice/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" + "time" +) + +// For a given DMS Serverless replication configuration, DMS connects to the +// source endpoint and collects the metadata to analyze the replication workload. +// Using this metadata, DMS then computes and provisions the required capacity and +// starts replicating to the target endpoint using the server resources that DMS +// has provisioned for the DMS Serverless replication. +func (c *Client) StartReplication(ctx context.Context, params *StartReplicationInput, optFns ...func(*Options)) (*StartReplicationOutput, error) { + if params == nil { + params = &StartReplicationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "StartReplication", params, optFns, c.addOperationStartReplicationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*StartReplicationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type StartReplicationInput struct { + + // The Amazon Resource Name of the replication for which to start replication. + // + // This member is required. + ReplicationConfigArn *string + + // The replication type. + // + // This member is required. + StartReplicationType *string + + // Indicates when you want a change data capture (CDC) operation to start. Use + // either CdcStartPosition or CdcStartTime to specify when you want a CDC + // operation to start. Specifying both values results in an error. The value can be + // in date, checkpoint, or LSN/SCN format. + CdcStartPosition *string + + // Indicates the start time for a change data capture (CDC) operation. Use either + // CdcStartTime or CdcStartPosition to specify when you want a CDC operation to + // start. Specifying both values results in an error. + CdcStartTime *time.Time + + // Indicates when you want a change data capture (CDC) operation to stop. The + // value can be either server time or commit time. + CdcStopPosition *string + + noSmithyDocumentSerde +} + +type StartReplicationOutput struct { + + // The replication that DMS started. + Replication *types.Replication + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationStartReplicationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpStartReplication{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpStartReplication{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpStartReplicationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartReplication(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 + } + return nil +} + +func newServiceMetadataMiddleware_opStartReplication(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "dms", + OperationName: "StartReplication", + } +} diff --git a/service/databasemigrationservice/api_op_StopReplication.go b/service/databasemigrationservice/api_op_StopReplication.go new file mode 100644 index 00000000000..fe23e2062d5 --- /dev/null +++ b/service/databasemigrationservice/api_op_StopReplication.go @@ -0,0 +1,126 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package databasemigrationservice + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/databasemigrationservice/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// For a given DMS Serverless replication configuration, DMS stops any and all +// ongoing DMS Serverless replications. This command doesn't deprovision the +// stopped replications. +func (c *Client) StopReplication(ctx context.Context, params *StopReplicationInput, optFns ...func(*Options)) (*StopReplicationOutput, error) { + if params == nil { + params = &StopReplicationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "StopReplication", params, optFns, c.addOperationStopReplicationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*StopReplicationOutput) + out.ResultMetadata = metadata + return out, nil +} + +type StopReplicationInput struct { + + // The Amazon Resource Name of the replication to stop. + // + // This member is required. + ReplicationConfigArn *string + + noSmithyDocumentSerde +} + +type StopReplicationOutput struct { + + // The replication that DMS stopped. + Replication *types.Replication + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationStopReplicationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsAwsjson11_serializeOpStopReplication{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpStopReplication{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpStopReplicationValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStopReplication(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 + } + return nil +} + +func newServiceMetadataMiddleware_opStopReplication(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "dms", + OperationName: "StopReplication", + } +} diff --git a/service/databasemigrationservice/deserializers.go b/service/databasemigrationservice/deserializers.go index c1d9ce12ea4..1c267bc95da 100644 --- a/service/databasemigrationservice/deserializers.go +++ b/service/databasemigrationservice/deserializers.go @@ -868,6 +868,138 @@ func awsAwsjson11_deserializeOpErrorCreateFleetAdvisorCollector(response *smithy } } +type awsAwsjson11_deserializeOpCreateReplicationConfig struct { +} + +func (*awsAwsjson11_deserializeOpCreateReplicationConfig) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpCreateReplicationConfig) HandleDeserialize(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_deserializeOpErrorCreateReplicationConfig(response, &metadata) + } + output := &CreateReplicationConfigOutput{} + 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_deserializeOpDocumentCreateReplicationConfigOutput(&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_deserializeOpErrorCreateReplicationConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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("AccessDeniedFault", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) + + case strings.EqualFold("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + + case strings.EqualFold("InvalidSubnet", errorCode): + return awsAwsjson11_deserializeErrorInvalidSubnet(response, errorBody) + + case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): + return awsAwsjson11_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) + + case strings.EqualFold("ReplicationSubnetGroupDoesNotCoverEnoughAZs", errorCode): + return awsAwsjson11_deserializeErrorReplicationSubnetGroupDoesNotCoverEnoughAZs(response, errorBody) + + case strings.EqualFold("ResourceAlreadyExistsFault", errorCode): + return awsAwsjson11_deserializeErrorResourceAlreadyExistsFault(response, errorBody) + + case strings.EqualFold("ResourceNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + + case strings.EqualFold("ResourceQuotaExceededFault", errorCode): + return awsAwsjson11_deserializeErrorResourceQuotaExceededFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsAwsjson11_deserializeOpCreateReplicationInstance struct { } @@ -1923,6 +2055,123 @@ func awsAwsjson11_deserializeOpErrorDeleteFleetAdvisorDatabases(response *smithy } } +type awsAwsjson11_deserializeOpDeleteReplicationConfig struct { +} + +func (*awsAwsjson11_deserializeOpDeleteReplicationConfig) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpDeleteReplicationConfig) HandleDeserialize(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_deserializeOpErrorDeleteReplicationConfig(response, &metadata) + } + output := &DeleteReplicationConfigOutput{} + 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_deserializeOpDocumentDeleteReplicationConfigOutput(&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_deserializeOpErrorDeleteReplicationConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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("AccessDeniedFault", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) + + case strings.EqualFold("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + + case strings.EqualFold("ResourceNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsAwsjson11_deserializeOpDeleteReplicationInstance struct { } @@ -4599,14 +4848,14 @@ func awsAwsjson11_deserializeOpErrorDescribeRefreshSchemasStatus(response *smith } } -type awsAwsjson11_deserializeOpDescribeReplicationInstances struct { +type awsAwsjson11_deserializeOpDescribeReplicationConfigs struct { } -func (*awsAwsjson11_deserializeOpDescribeReplicationInstances) ID() string { +func (*awsAwsjson11_deserializeOpDescribeReplicationConfigs) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeReplicationInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeReplicationConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4620,9 +4869,9 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationInstances) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationInstances(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationConfigs(response, &metadata) } - output := &DescribeReplicationInstancesOutput{} + output := &DescribeReplicationConfigsOutput{} out.Result = output var buff [1024]byte @@ -4642,7 +4891,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationInstances) HandleDeseriali return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeReplicationInstancesOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeReplicationConfigsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4656,7 +4905,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationInstances) HandleDeseriali return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeReplicationInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeReplicationConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4710,14 +4959,14 @@ func awsAwsjson11_deserializeOpErrorDescribeReplicationInstances(response *smith } } -type awsAwsjson11_deserializeOpDescribeReplicationInstanceTaskLogs struct { +type awsAwsjson11_deserializeOpDescribeReplicationInstances struct { } -func (*awsAwsjson11_deserializeOpDescribeReplicationInstanceTaskLogs) ID() string { +func (*awsAwsjson11_deserializeOpDescribeReplicationInstances) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeReplicationInstanceTaskLogs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeReplicationInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4731,9 +4980,9 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationInstanceTaskLogs) HandleDe } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationInstanceTaskLogs(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationInstances(response, &metadata) } - output := &DescribeReplicationInstanceTaskLogsOutput{} + output := &DescribeReplicationInstancesOutput{} out.Result = output var buff [1024]byte @@ -4753,7 +5002,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationInstanceTaskLogs) HandleDe return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeReplicationInstanceTaskLogsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeReplicationInstancesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4767,7 +5016,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationInstanceTaskLogs) HandleDe return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeReplicationInstanceTaskLogs(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeReplicationInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4808,9 +5057,6 @@ func awsAwsjson11_deserializeOpErrorDescribeReplicationInstanceTaskLogs(response } switch { - case strings.EqualFold("InvalidResourceStateFault", errorCode): - return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) - case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) @@ -4824,14 +5070,14 @@ func awsAwsjson11_deserializeOpErrorDescribeReplicationInstanceTaskLogs(response } } -type awsAwsjson11_deserializeOpDescribeReplicationSubnetGroups struct { +type awsAwsjson11_deserializeOpDescribeReplicationInstanceTaskLogs struct { } -func (*awsAwsjson11_deserializeOpDescribeReplicationSubnetGroups) ID() string { +func (*awsAwsjson11_deserializeOpDescribeReplicationInstanceTaskLogs) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeReplicationSubnetGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeReplicationInstanceTaskLogs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4845,9 +5091,9 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationSubnetGroups) HandleDeseri } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationSubnetGroups(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationInstanceTaskLogs(response, &metadata) } - output := &DescribeReplicationSubnetGroupsOutput{} + output := &DescribeReplicationInstanceTaskLogsOutput{} out.Result = output var buff [1024]byte @@ -4867,7 +5113,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationSubnetGroups) HandleDeseri return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeReplicationSubnetGroupsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeReplicationInstanceTaskLogsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4881,7 +5127,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationSubnetGroups) HandleDeseri return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeReplicationSubnetGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeReplicationInstanceTaskLogs(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -4922,6 +5168,9 @@ func awsAwsjson11_deserializeOpErrorDescribeReplicationSubnetGroups(response *sm } switch { + case strings.EqualFold("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) @@ -4935,14 +5184,14 @@ func awsAwsjson11_deserializeOpErrorDescribeReplicationSubnetGroups(response *sm } } -type awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentResults struct { +type awsAwsjson11_deserializeOpDescribeReplications struct { } -func (*awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentResults) ID() string { +func (*awsAwsjson11_deserializeOpDescribeReplications) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentResults) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeReplications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -4956,9 +5205,9 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentResults) Han } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationTaskAssessmentResults(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplications(response, &metadata) } - output := &DescribeReplicationTaskAssessmentResultsOutput{} + output := &DescribeReplicationsOutput{} out.Result = output var buff [1024]byte @@ -4978,7 +5227,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentResults) Han return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeReplicationTaskAssessmentResultsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeReplicationsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -4992,7 +5241,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentResults) Han return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeReplicationTaskAssessmentResults(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeReplications(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5046,14 +5295,14 @@ func awsAwsjson11_deserializeOpErrorDescribeReplicationTaskAssessmentResults(res } } -type awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentRuns struct { +type awsAwsjson11_deserializeOpDescribeReplicationSubnetGroups struct { } -func (*awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentRuns) ID() string { +func (*awsAwsjson11_deserializeOpDescribeReplicationSubnetGroups) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentRuns) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeReplicationSubnetGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5067,9 +5316,9 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentRuns) Handle } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationTaskAssessmentRuns(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationSubnetGroups(response, &metadata) } - output := &DescribeReplicationTaskAssessmentRunsOutput{} + output := &DescribeReplicationSubnetGroupsOutput{} out.Result = output var buff [1024]byte @@ -5089,7 +5338,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentRuns) Handle return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeReplicationTaskAssessmentRunsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeReplicationSubnetGroupsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5103,7 +5352,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentRuns) Handle return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeReplicationTaskAssessmentRuns(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeReplicationSubnetGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5157,14 +5406,14 @@ func awsAwsjson11_deserializeOpErrorDescribeReplicationTaskAssessmentRuns(respon } } -type awsAwsjson11_deserializeOpDescribeReplicationTaskIndividualAssessments struct { +type awsAwsjson11_deserializeOpDescribeReplicationTableStatistics struct { } -func (*awsAwsjson11_deserializeOpDescribeReplicationTaskIndividualAssessments) ID() string { +func (*awsAwsjson11_deserializeOpDescribeReplicationTableStatistics) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskIndividualAssessments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeReplicationTableStatistics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5178,9 +5427,9 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskIndividualAssessments) } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationTaskIndividualAssessments(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationTableStatistics(response, &metadata) } - output := &DescribeReplicationTaskIndividualAssessmentsOutput{} + output := &DescribeReplicationTableStatisticsOutput{} out.Result = output var buff [1024]byte @@ -5200,7 +5449,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskIndividualAssessments) return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeReplicationTaskIndividualAssessmentsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeReplicationTableStatisticsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5214,7 +5463,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskIndividualAssessments) return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeReplicationTaskIndividualAssessments(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeReplicationTableStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5255,6 +5504,9 @@ func awsAwsjson11_deserializeOpErrorDescribeReplicationTaskIndividualAssessments } switch { + case strings.EqualFold("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) @@ -5268,14 +5520,14 @@ func awsAwsjson11_deserializeOpErrorDescribeReplicationTaskIndividualAssessments } } -type awsAwsjson11_deserializeOpDescribeReplicationTasks struct { +type awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentResults struct { } -func (*awsAwsjson11_deserializeOpDescribeReplicationTasks) ID() string { +func (*awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentResults) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeReplicationTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentResults) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5289,9 +5541,9 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationTasks) HandleDeserialize(c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationTasks(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationTaskAssessmentResults(response, &metadata) } - output := &DescribeReplicationTasksOutput{} + output := &DescribeReplicationTaskAssessmentResultsOutput{} out.Result = output var buff [1024]byte @@ -5311,7 +5563,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationTasks) HandleDeserialize(c return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeReplicationTasksOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeReplicationTaskAssessmentResultsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5325,7 +5577,7 @@ func (m *awsAwsjson11_deserializeOpDescribeReplicationTasks) HandleDeserialize(c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeReplicationTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeReplicationTaskAssessmentResults(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5379,14 +5631,14 @@ func awsAwsjson11_deserializeOpErrorDescribeReplicationTasks(response *smithyhtt } } -type awsAwsjson11_deserializeOpDescribeSchemas struct { +type awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentRuns struct { } -func (*awsAwsjson11_deserializeOpDescribeSchemas) ID() string { +func (*awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentRuns) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeSchemas) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskAssessmentRuns) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5400,9 +5652,9 @@ func (m *awsAwsjson11_deserializeOpDescribeSchemas) HandleDeserialize(ctx contex } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeSchemas(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationTaskAssessmentRuns(response, &metadata) } - output := &DescribeSchemasOutput{} + output := &DescribeReplicationTaskAssessmentRunsOutput{} out.Result = output var buff [1024]byte @@ -5422,7 +5674,7 @@ func (m *awsAwsjson11_deserializeOpDescribeSchemas) HandleDeserialize(ctx contex return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeSchemasOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeReplicationTaskAssessmentRunsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5436,7 +5688,7 @@ func (m *awsAwsjson11_deserializeOpDescribeSchemas) HandleDeserialize(ctx contex return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeSchemas(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeReplicationTaskAssessmentRuns(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5477,9 +5729,6 @@ func awsAwsjson11_deserializeOpErrorDescribeSchemas(response *smithyhttp.Respons } switch { - case strings.EqualFold("InvalidResourceStateFault", errorCode): - return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) - case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) @@ -5493,14 +5742,14 @@ func awsAwsjson11_deserializeOpErrorDescribeSchemas(response *smithyhttp.Respons } } -type awsAwsjson11_deserializeOpDescribeTableStatistics struct { +type awsAwsjson11_deserializeOpDescribeReplicationTaskIndividualAssessments struct { } -func (*awsAwsjson11_deserializeOpDescribeTableStatistics) ID() string { +func (*awsAwsjson11_deserializeOpDescribeReplicationTaskIndividualAssessments) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpDescribeTableStatistics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeReplicationTaskIndividualAssessments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5514,9 +5763,9 @@ func (m *awsAwsjson11_deserializeOpDescribeTableStatistics) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTableStatistics(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationTaskIndividualAssessments(response, &metadata) } - output := &DescribeTableStatisticsOutput{} + output := &DescribeReplicationTaskIndividualAssessmentsOutput{} out.Result = output var buff [1024]byte @@ -5536,7 +5785,7 @@ func (m *awsAwsjson11_deserializeOpDescribeTableStatistics) HandleDeserialize(ct return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentDescribeTableStatisticsOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeReplicationTaskIndividualAssessmentsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5550,7 +5799,7 @@ func (m *awsAwsjson11_deserializeOpDescribeTableStatistics) HandleDeserialize(ct return out, metadata, err } -func awsAwsjson11_deserializeOpErrorDescribeTableStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeReplicationTaskIndividualAssessments(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5591,9 +5840,6 @@ func awsAwsjson11_deserializeOpErrorDescribeTableStatistics(response *smithyhttp } switch { - case strings.EqualFold("InvalidResourceStateFault", errorCode): - return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) - case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) @@ -5607,14 +5853,14 @@ func awsAwsjson11_deserializeOpErrorDescribeTableStatistics(response *smithyhttp } } -type awsAwsjson11_deserializeOpImportCertificate struct { +type awsAwsjson11_deserializeOpDescribeReplicationTasks struct { } -func (*awsAwsjson11_deserializeOpImportCertificate) ID() string { +func (*awsAwsjson11_deserializeOpDescribeReplicationTasks) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpImportCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeReplicationTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5628,9 +5874,9 @@ func (m *awsAwsjson11_deserializeOpImportCertificate) HandleDeserialize(ctx cont } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorImportCertificate(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReplicationTasks(response, &metadata) } - output := &ImportCertificateOutput{} + output := &DescribeReplicationTasksOutput{} out.Result = output var buff [1024]byte @@ -5650,7 +5896,7 @@ func (m *awsAwsjson11_deserializeOpImportCertificate) HandleDeserialize(ctx cont return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentImportCertificateOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeReplicationTasksOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5664,7 +5910,7 @@ func (m *awsAwsjson11_deserializeOpImportCertificate) HandleDeserialize(ctx cont return out, metadata, err } -func awsAwsjson11_deserializeOpErrorImportCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeReplicationTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5705,14 +5951,8 @@ func awsAwsjson11_deserializeOpErrorImportCertificate(response *smithyhttp.Respo } switch { - case strings.EqualFold("InvalidCertificateFault", errorCode): - return awsAwsjson11_deserializeErrorInvalidCertificateFault(response, errorBody) - - case strings.EqualFold("ResourceAlreadyExistsFault", errorCode): - return awsAwsjson11_deserializeErrorResourceAlreadyExistsFault(response, errorBody) - - case strings.EqualFold("ResourceQuotaExceededFault", errorCode): - return awsAwsjson11_deserializeErrorResourceQuotaExceededFault(response, errorBody) + case strings.EqualFold("ResourceNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -5724,14 +5964,14 @@ func awsAwsjson11_deserializeOpErrorImportCertificate(response *smithyhttp.Respo } } -type awsAwsjson11_deserializeOpListTagsForResource struct { +type awsAwsjson11_deserializeOpDescribeSchemas struct { } -func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { +func (*awsAwsjson11_deserializeOpDescribeSchemas) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeSchemas) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5745,9 +5985,9 @@ func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeSchemas(response, &metadata) } - output := &ListTagsForResourceOutput{} + output := &DescribeSchemasOutput{} out.Result = output var buff [1024]byte @@ -5767,7 +6007,7 @@ func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx co return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeSchemasOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5781,7 +6021,7 @@ func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx co return out, metadata, err } -func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeSchemas(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5822,6 +6062,9 @@ func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Res } switch { + case strings.EqualFold("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) @@ -5835,14 +6078,14 @@ func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Res } } -type awsAwsjson11_deserializeOpModifyEndpoint struct { +type awsAwsjson11_deserializeOpDescribeTableStatistics struct { } -func (*awsAwsjson11_deserializeOpModifyEndpoint) ID() string { +func (*awsAwsjson11_deserializeOpDescribeTableStatistics) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpModifyEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpDescribeTableStatistics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5856,9 +6099,9 @@ func (m *awsAwsjson11_deserializeOpModifyEndpoint) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorModifyEndpoint(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTableStatistics(response, &metadata) } - output := &ModifyEndpointOutput{} + output := &DescribeTableStatisticsOutput{} out.Result = output var buff [1024]byte @@ -5878,7 +6121,7 @@ func (m *awsAwsjson11_deserializeOpModifyEndpoint) HandleDeserialize(ctx context return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentModifyEndpointOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentDescribeTableStatisticsOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -5892,7 +6135,7 @@ func (m *awsAwsjson11_deserializeOpModifyEndpoint) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsjson11_deserializeOpErrorModifyEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorDescribeTableStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -5933,18 +6176,9 @@ func awsAwsjson11_deserializeOpErrorModifyEndpoint(response *smithyhttp.Response } switch { - case strings.EqualFold("AccessDeniedFault", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) - case strings.EqualFold("InvalidResourceStateFault", errorCode): return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) - case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): - return awsAwsjson11_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) - - case strings.EqualFold("ResourceAlreadyExistsFault", errorCode): - return awsAwsjson11_deserializeErrorResourceAlreadyExistsFault(response, errorBody) - case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) @@ -5958,14 +6192,14 @@ func awsAwsjson11_deserializeOpErrorModifyEndpoint(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpModifyEventSubscription struct { +type awsAwsjson11_deserializeOpImportCertificate struct { } -func (*awsAwsjson11_deserializeOpModifyEventSubscription) ID() string { +func (*awsAwsjson11_deserializeOpImportCertificate) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpModifyEventSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpImportCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -5979,9 +6213,9 @@ func (m *awsAwsjson11_deserializeOpModifyEventSubscription) HandleDeserialize(ct } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorModifyEventSubscription(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorImportCertificate(response, &metadata) } - output := &ModifyEventSubscriptionOutput{} + output := &ImportCertificateOutput{} out.Result = output var buff [1024]byte @@ -6001,7 +6235,7 @@ func (m *awsAwsjson11_deserializeOpModifyEventSubscription) HandleDeserialize(ct return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentModifyEventSubscriptionOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentImportCertificateOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6015,7 +6249,7 @@ func (m *awsAwsjson11_deserializeOpModifyEventSubscription) HandleDeserialize(ct return out, metadata, err } -func awsAwsjson11_deserializeOpErrorModifyEventSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorImportCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6056,33 +6290,15 @@ func awsAwsjson11_deserializeOpErrorModifyEventSubscription(response *smithyhttp } switch { - case strings.EqualFold("KMSAccessDeniedFault", errorCode): - return awsAwsjson11_deserializeErrorKMSAccessDeniedFault(response, errorBody) - - case strings.EqualFold("KMSDisabledFault", errorCode): - return awsAwsjson11_deserializeErrorKMSDisabledFault(response, errorBody) - - case strings.EqualFold("KMSInvalidStateFault", errorCode): - return awsAwsjson11_deserializeErrorKMSInvalidStateFault(response, errorBody) - - case strings.EqualFold("KMSNotFoundFault", errorCode): - return awsAwsjson11_deserializeErrorKMSNotFoundFault(response, errorBody) - - case strings.EqualFold("KMSThrottlingFault", errorCode): - return awsAwsjson11_deserializeErrorKMSThrottlingFault(response, errorBody) + case strings.EqualFold("InvalidCertificateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidCertificateFault(response, errorBody) - case strings.EqualFold("ResourceNotFoundFault", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + case strings.EqualFold("ResourceAlreadyExistsFault", errorCode): + return awsAwsjson11_deserializeErrorResourceAlreadyExistsFault(response, errorBody) case strings.EqualFold("ResourceQuotaExceededFault", errorCode): return awsAwsjson11_deserializeErrorResourceQuotaExceededFault(response, errorBody) - case strings.EqualFold("SNSInvalidTopicFault", errorCode): - return awsAwsjson11_deserializeErrorSNSInvalidTopicFault(response, errorBody) - - case strings.EqualFold("SNSNoAuthorizationFault", errorCode): - return awsAwsjson11_deserializeErrorSNSNoAuthorizationFault(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -6093,14 +6309,14 @@ func awsAwsjson11_deserializeOpErrorModifyEventSubscription(response *smithyhttp } } -type awsAwsjson11_deserializeOpModifyReplicationInstance struct { +type awsAwsjson11_deserializeOpListTagsForResource struct { } -func (*awsAwsjson11_deserializeOpModifyReplicationInstance) ID() string { +func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpModifyReplicationInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6114,9 +6330,9 @@ func (m *awsAwsjson11_deserializeOpModifyReplicationInstance) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorModifyReplicationInstance(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) } - output := &ModifyReplicationInstanceOutput{} + output := &ListTagsForResourceOutput{} out.Result = output var buff [1024]byte @@ -6136,7 +6352,7 @@ func (m *awsAwsjson11_deserializeOpModifyReplicationInstance) HandleDeserialize( return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentModifyReplicationInstanceOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6150,7 +6366,7 @@ func (m *awsAwsjson11_deserializeOpModifyReplicationInstance) HandleDeserialize( return out, metadata, err } -func awsAwsjson11_deserializeOpErrorModifyReplicationInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6191,27 +6407,9 @@ func awsAwsjson11_deserializeOpErrorModifyReplicationInstance(response *smithyht } switch { - case strings.EqualFold("AccessDeniedFault", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) - - case strings.EqualFold("InsufficientResourceCapacityFault", errorCode): - return awsAwsjson11_deserializeErrorInsufficientResourceCapacityFault(response, errorBody) - - case strings.EqualFold("InvalidResourceStateFault", errorCode): - return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) - - case strings.EqualFold("ResourceAlreadyExistsFault", errorCode): - return awsAwsjson11_deserializeErrorResourceAlreadyExistsFault(response, errorBody) - case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) - case strings.EqualFold("StorageQuotaExceededFault", errorCode): - return awsAwsjson11_deserializeErrorStorageQuotaExceededFault(response, errorBody) - - case strings.EqualFold("UpgradeDependencyFailureFault", errorCode): - return awsAwsjson11_deserializeErrorUpgradeDependencyFailureFault(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -6222,14 +6420,14 @@ func awsAwsjson11_deserializeOpErrorModifyReplicationInstance(response *smithyht } } -type awsAwsjson11_deserializeOpModifyReplicationSubnetGroup struct { +type awsAwsjson11_deserializeOpModifyEndpoint struct { } -func (*awsAwsjson11_deserializeOpModifyReplicationSubnetGroup) ID() string { +func (*awsAwsjson11_deserializeOpModifyEndpoint) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpModifyReplicationSubnetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpModifyEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6243,9 +6441,9 @@ func (m *awsAwsjson11_deserializeOpModifyReplicationSubnetGroup) HandleDeseriali } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorModifyReplicationSubnetGroup(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorModifyEndpoint(response, &metadata) } - output := &ModifyReplicationSubnetGroupOutput{} + output := &ModifyEndpointOutput{} out.Result = output var buff [1024]byte @@ -6265,7 +6463,7 @@ func (m *awsAwsjson11_deserializeOpModifyReplicationSubnetGroup) HandleDeseriali return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentModifyReplicationSubnetGroupOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentModifyEndpointOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6279,7 +6477,7 @@ func (m *awsAwsjson11_deserializeOpModifyReplicationSubnetGroup) HandleDeseriali return out, metadata, err } -func awsAwsjson11_deserializeOpErrorModifyReplicationSubnetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorModifyEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6323,20 +6521,17 @@ func awsAwsjson11_deserializeOpErrorModifyReplicationSubnetGroup(response *smith case strings.EqualFold("AccessDeniedFault", errorCode): return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) - case strings.EqualFold("InvalidSubnet", errorCode): - return awsAwsjson11_deserializeErrorInvalidSubnet(response, errorBody) - - case strings.EqualFold("ReplicationSubnetGroupDoesNotCoverEnoughAZs", errorCode): - return awsAwsjson11_deserializeErrorReplicationSubnetGroupDoesNotCoverEnoughAZs(response, errorBody) + case strings.EqualFold("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) - case strings.EqualFold("ResourceNotFoundFault", errorCode): - return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): + return awsAwsjson11_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) - case strings.EqualFold("ResourceQuotaExceededFault", errorCode): - return awsAwsjson11_deserializeErrorResourceQuotaExceededFault(response, errorBody) + case strings.EqualFold("ResourceAlreadyExistsFault", errorCode): + return awsAwsjson11_deserializeErrorResourceAlreadyExistsFault(response, errorBody) - case strings.EqualFold("SubnetAlreadyInUse", errorCode): - return awsAwsjson11_deserializeErrorSubnetAlreadyInUse(response, errorBody) + case strings.EqualFold("ResourceNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) default: genericError := &smithy.GenericAPIError{ @@ -6348,14 +6543,14 @@ func awsAwsjson11_deserializeOpErrorModifyReplicationSubnetGroup(response *smith } } -type awsAwsjson11_deserializeOpModifyReplicationTask struct { +type awsAwsjson11_deserializeOpModifyEventSubscription struct { } -func (*awsAwsjson11_deserializeOpModifyReplicationTask) ID() string { +func (*awsAwsjson11_deserializeOpModifyEventSubscription) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpModifyReplicationTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpModifyEventSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6369,9 +6564,9 @@ func (m *awsAwsjson11_deserializeOpModifyReplicationTask) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorModifyReplicationTask(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorModifyEventSubscription(response, &metadata) } - output := &ModifyReplicationTaskOutput{} + output := &ModifyEventSubscriptionOutput{} out.Result = output var buff [1024]byte @@ -6391,7 +6586,7 @@ func (m *awsAwsjson11_deserializeOpModifyReplicationTask) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentModifyReplicationTaskOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentModifyEventSubscriptionOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6405,7 +6600,7 @@ func (m *awsAwsjson11_deserializeOpModifyReplicationTask) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson11_deserializeOpErrorModifyReplicationTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorModifyEventSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6446,18 +6641,33 @@ func awsAwsjson11_deserializeOpErrorModifyReplicationTask(response *smithyhttp.R } switch { - case strings.EqualFold("InvalidResourceStateFault", errorCode): - return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + case strings.EqualFold("KMSAccessDeniedFault", errorCode): + return awsAwsjson11_deserializeErrorKMSAccessDeniedFault(response, errorBody) - case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): - return awsAwsjson11_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) + case strings.EqualFold("KMSDisabledFault", errorCode): + return awsAwsjson11_deserializeErrorKMSDisabledFault(response, errorBody) - case strings.EqualFold("ResourceAlreadyExistsFault", errorCode): - return awsAwsjson11_deserializeErrorResourceAlreadyExistsFault(response, errorBody) + case strings.EqualFold("KMSInvalidStateFault", errorCode): + return awsAwsjson11_deserializeErrorKMSInvalidStateFault(response, errorBody) + + case strings.EqualFold("KMSNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorKMSNotFoundFault(response, errorBody) + + case strings.EqualFold("KMSThrottlingFault", errorCode): + return awsAwsjson11_deserializeErrorKMSThrottlingFault(response, errorBody) case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + case strings.EqualFold("ResourceQuotaExceededFault", errorCode): + return awsAwsjson11_deserializeErrorResourceQuotaExceededFault(response, errorBody) + + case strings.EqualFold("SNSInvalidTopicFault", errorCode): + return awsAwsjson11_deserializeErrorSNSInvalidTopicFault(response, errorBody) + + case strings.EqualFold("SNSNoAuthorizationFault", errorCode): + return awsAwsjson11_deserializeErrorSNSNoAuthorizationFault(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -6468,14 +6678,14 @@ func awsAwsjson11_deserializeOpErrorModifyReplicationTask(response *smithyhttp.R } } -type awsAwsjson11_deserializeOpMoveReplicationTask struct { +type awsAwsjson11_deserializeOpModifyReplicationConfig struct { } -func (*awsAwsjson11_deserializeOpMoveReplicationTask) ID() string { +func (*awsAwsjson11_deserializeOpModifyReplicationConfig) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpMoveReplicationTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpModifyReplicationConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6489,9 +6699,9 @@ func (m *awsAwsjson11_deserializeOpMoveReplicationTask) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorMoveReplicationTask(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorModifyReplicationConfig(response, &metadata) } - output := &MoveReplicationTaskOutput{} + output := &ModifyReplicationConfigOutput{} out.Result = output var buff [1024]byte @@ -6511,7 +6721,7 @@ func (m *awsAwsjson11_deserializeOpMoveReplicationTask) HandleDeserialize(ctx co return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentMoveReplicationTaskOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentModifyReplicationConfigOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6525,7 +6735,7 @@ func (m *awsAwsjson11_deserializeOpMoveReplicationTask) HandleDeserialize(ctx co return out, metadata, err } -func awsAwsjson11_deserializeOpErrorMoveReplicationTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorModifyReplicationConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6572,15 +6782,18 @@ func awsAwsjson11_deserializeOpErrorMoveReplicationTask(response *smithyhttp.Res case strings.EqualFold("InvalidResourceStateFault", errorCode): return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + case strings.EqualFold("InvalidSubnet", errorCode): + return awsAwsjson11_deserializeErrorInvalidSubnet(response, errorBody) + case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): return awsAwsjson11_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) + case strings.EqualFold("ReplicationSubnetGroupDoesNotCoverEnoughAZs", errorCode): + return awsAwsjson11_deserializeErrorReplicationSubnetGroupDoesNotCoverEnoughAZs(response, errorBody) + case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) - case strings.EqualFold("ResourceQuotaExceededFault", errorCode): - return awsAwsjson11_deserializeErrorResourceQuotaExceededFault(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -6591,14 +6804,14 @@ func awsAwsjson11_deserializeOpErrorMoveReplicationTask(response *smithyhttp.Res } } -type awsAwsjson11_deserializeOpRebootReplicationInstance struct { +type awsAwsjson11_deserializeOpModifyReplicationInstance struct { } -func (*awsAwsjson11_deserializeOpRebootReplicationInstance) ID() string { +func (*awsAwsjson11_deserializeOpModifyReplicationInstance) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpRebootReplicationInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpModifyReplicationInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6612,9 +6825,9 @@ func (m *awsAwsjson11_deserializeOpRebootReplicationInstance) HandleDeserialize( } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorRebootReplicationInstance(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorModifyReplicationInstance(response, &metadata) } - output := &RebootReplicationInstanceOutput{} + output := &ModifyReplicationInstanceOutput{} out.Result = output var buff [1024]byte @@ -6634,7 +6847,7 @@ func (m *awsAwsjson11_deserializeOpRebootReplicationInstance) HandleDeserialize( return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentRebootReplicationInstanceOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentModifyReplicationInstanceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6648,7 +6861,7 @@ func (m *awsAwsjson11_deserializeOpRebootReplicationInstance) HandleDeserialize( return out, metadata, err } -func awsAwsjson11_deserializeOpErrorRebootReplicationInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorModifyReplicationInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6689,12 +6902,27 @@ func awsAwsjson11_deserializeOpErrorRebootReplicationInstance(response *smithyht } switch { + case strings.EqualFold("AccessDeniedFault", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) + + case strings.EqualFold("InsufficientResourceCapacityFault", errorCode): + return awsAwsjson11_deserializeErrorInsufficientResourceCapacityFault(response, errorBody) + case strings.EqualFold("InvalidResourceStateFault", errorCode): return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + case strings.EqualFold("ResourceAlreadyExistsFault", errorCode): + return awsAwsjson11_deserializeErrorResourceAlreadyExistsFault(response, errorBody) + case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + case strings.EqualFold("StorageQuotaExceededFault", errorCode): + return awsAwsjson11_deserializeErrorStorageQuotaExceededFault(response, errorBody) + + case strings.EqualFold("UpgradeDependencyFailureFault", errorCode): + return awsAwsjson11_deserializeErrorUpgradeDependencyFailureFault(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -6705,14 +6933,14 @@ func awsAwsjson11_deserializeOpErrorRebootReplicationInstance(response *smithyht } } -type awsAwsjson11_deserializeOpRefreshSchemas struct { +type awsAwsjson11_deserializeOpModifyReplicationSubnetGroup struct { } -func (*awsAwsjson11_deserializeOpRefreshSchemas) ID() string { +func (*awsAwsjson11_deserializeOpModifyReplicationSubnetGroup) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpRefreshSchemas) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpModifyReplicationSubnetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6726,9 +6954,9 @@ func (m *awsAwsjson11_deserializeOpRefreshSchemas) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorRefreshSchemas(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorModifyReplicationSubnetGroup(response, &metadata) } - output := &RefreshSchemasOutput{} + output := &ModifyReplicationSubnetGroupOutput{} out.Result = output var buff [1024]byte @@ -6748,7 +6976,7 @@ func (m *awsAwsjson11_deserializeOpRefreshSchemas) HandleDeserialize(ctx context return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentRefreshSchemasOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentModifyReplicationSubnetGroupOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6762,7 +6990,7 @@ func (m *awsAwsjson11_deserializeOpRefreshSchemas) HandleDeserialize(ctx context return out, metadata, err } -func awsAwsjson11_deserializeOpErrorRefreshSchemas(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorModifyReplicationSubnetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6803,11 +7031,14 @@ func awsAwsjson11_deserializeOpErrorRefreshSchemas(response *smithyhttp.Response } switch { - case strings.EqualFold("InvalidResourceStateFault", errorCode): - return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + case strings.EqualFold("AccessDeniedFault", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) - case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): - return awsAwsjson11_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) + case strings.EqualFold("InvalidSubnet", errorCode): + return awsAwsjson11_deserializeErrorInvalidSubnet(response, errorBody) + + case strings.EqualFold("ReplicationSubnetGroupDoesNotCoverEnoughAZs", errorCode): + return awsAwsjson11_deserializeErrorReplicationSubnetGroupDoesNotCoverEnoughAZs(response, errorBody) case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) @@ -6815,6 +7046,9 @@ func awsAwsjson11_deserializeOpErrorRefreshSchemas(response *smithyhttp.Response case strings.EqualFold("ResourceQuotaExceededFault", errorCode): return awsAwsjson11_deserializeErrorResourceQuotaExceededFault(response, errorBody) + case strings.EqualFold("SubnetAlreadyInUse", errorCode): + return awsAwsjson11_deserializeErrorSubnetAlreadyInUse(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -6825,14 +7059,14 @@ func awsAwsjson11_deserializeOpErrorRefreshSchemas(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpReloadTables struct { +type awsAwsjson11_deserializeOpModifyReplicationTask struct { } -func (*awsAwsjson11_deserializeOpReloadTables) ID() string { +func (*awsAwsjson11_deserializeOpModifyReplicationTask) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpReloadTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpModifyReplicationTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6846,9 +7080,9 @@ func (m *awsAwsjson11_deserializeOpReloadTables) HandleDeserialize(ctx context.C } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorReloadTables(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorModifyReplicationTask(response, &metadata) } - output := &ReloadTablesOutput{} + output := &ModifyReplicationTaskOutput{} out.Result = output var buff [1024]byte @@ -6868,7 +7102,7 @@ func (m *awsAwsjson11_deserializeOpReloadTables) HandleDeserialize(ctx context.C return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentReloadTablesOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentModifyReplicationTaskOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6882,7 +7116,7 @@ func (m *awsAwsjson11_deserializeOpReloadTables) HandleDeserialize(ctx context.C return out, metadata, err } -func awsAwsjson11_deserializeOpErrorReloadTables(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorModifyReplicationTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -6926,6 +7160,12 @@ func awsAwsjson11_deserializeOpErrorReloadTables(response *smithyhttp.Response, case strings.EqualFold("InvalidResourceStateFault", errorCode): return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): + return awsAwsjson11_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) + + case strings.EqualFold("ResourceAlreadyExistsFault", errorCode): + return awsAwsjson11_deserializeErrorResourceAlreadyExistsFault(response, errorBody) + case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) @@ -6939,14 +7179,14 @@ func awsAwsjson11_deserializeOpErrorReloadTables(response *smithyhttp.Response, } } -type awsAwsjson11_deserializeOpRemoveTagsFromResource struct { +type awsAwsjson11_deserializeOpMoveReplicationTask struct { } -func (*awsAwsjson11_deserializeOpRemoveTagsFromResource) ID() string { +func (*awsAwsjson11_deserializeOpMoveReplicationTask) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpRemoveTagsFromResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpMoveReplicationTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -6960,9 +7200,9 @@ func (m *awsAwsjson11_deserializeOpRemoveTagsFromResource) HandleDeserialize(ctx } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorRemoveTagsFromResource(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorMoveReplicationTask(response, &metadata) } - output := &RemoveTagsFromResourceOutput{} + output := &MoveReplicationTaskOutput{} out.Result = output var buff [1024]byte @@ -6982,7 +7222,7 @@ func (m *awsAwsjson11_deserializeOpRemoveTagsFromResource) HandleDeserialize(ctx return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentRemoveTagsFromResourceOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentMoveReplicationTaskOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -6996,7 +7236,7 @@ func (m *awsAwsjson11_deserializeOpRemoveTagsFromResource) HandleDeserialize(ctx return out, metadata, err } -func awsAwsjson11_deserializeOpErrorRemoveTagsFromResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorMoveReplicationTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7037,9 +7277,21 @@ func awsAwsjson11_deserializeOpErrorRemoveTagsFromResource(response *smithyhttp. } switch { + case strings.EqualFold("AccessDeniedFault", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) + + case strings.EqualFold("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + + case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): + return awsAwsjson11_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) + case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + case strings.EqualFold("ResourceQuotaExceededFault", errorCode): + return awsAwsjson11_deserializeErrorResourceQuotaExceededFault(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -7050,14 +7302,14 @@ func awsAwsjson11_deserializeOpErrorRemoveTagsFromResource(response *smithyhttp. } } -type awsAwsjson11_deserializeOpRunFleetAdvisorLsaAnalysis struct { +type awsAwsjson11_deserializeOpRebootReplicationInstance struct { } -func (*awsAwsjson11_deserializeOpRunFleetAdvisorLsaAnalysis) ID() string { +func (*awsAwsjson11_deserializeOpRebootReplicationInstance) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpRunFleetAdvisorLsaAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpRebootReplicationInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7071,9 +7323,9 @@ func (m *awsAwsjson11_deserializeOpRunFleetAdvisorLsaAnalysis) HandleDeserialize } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorRunFleetAdvisorLsaAnalysis(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorRebootReplicationInstance(response, &metadata) } - output := &RunFleetAdvisorLsaAnalysisOutput{} + output := &RebootReplicationInstanceOutput{} out.Result = output var buff [1024]byte @@ -7093,7 +7345,7 @@ func (m *awsAwsjson11_deserializeOpRunFleetAdvisorLsaAnalysis) HandleDeserialize return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentRunFleetAdvisorLsaAnalysisOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentRebootReplicationInstanceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7107,7 +7359,7 @@ func (m *awsAwsjson11_deserializeOpRunFleetAdvisorLsaAnalysis) HandleDeserialize return out, metadata, err } -func awsAwsjson11_deserializeOpErrorRunFleetAdvisorLsaAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorRebootReplicationInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7164,14 +7416,14 @@ func awsAwsjson11_deserializeOpErrorRunFleetAdvisorLsaAnalysis(response *smithyh } } -type awsAwsjson11_deserializeOpStartRecommendations struct { +type awsAwsjson11_deserializeOpRefreshSchemas struct { } -func (*awsAwsjson11_deserializeOpStartRecommendations) ID() string { +func (*awsAwsjson11_deserializeOpRefreshSchemas) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpStartRecommendations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpRefreshSchemas) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7185,21 +7437,43 @@ func (m *awsAwsjson11_deserializeOpStartRecommendations) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorStartRecommendations(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorRefreshSchemas(response, &metadata) } - output := &StartRecommendationsOutput{} + output := &RefreshSchemasOutput{} out.Result = output - if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { - return out, metadata, &smithy.DeserializationError{ - Err: fmt.Errorf("failed to discard response body, %w", err), + var 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_deserializeOpDocumentRefreshSchemasOutput(&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_deserializeOpErrorStartRecommendations(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorRefreshSchemas(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7240,15 +7514,18 @@ func awsAwsjson11_deserializeOpErrorStartRecommendations(response *smithyhttp.Re } switch { - case strings.EqualFold("AccessDeniedFault", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) - case strings.EqualFold("InvalidResourceStateFault", errorCode): return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): + return awsAwsjson11_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) + case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + case strings.EqualFold("ResourceQuotaExceededFault", errorCode): + return awsAwsjson11_deserializeErrorResourceQuotaExceededFault(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -7259,14 +7536,14 @@ func awsAwsjson11_deserializeOpErrorStartRecommendations(response *smithyhttp.Re } } -type awsAwsjson11_deserializeOpStartReplicationTask struct { +type awsAwsjson11_deserializeOpReloadReplicationTables struct { } -func (*awsAwsjson11_deserializeOpStartReplicationTask) ID() string { +func (*awsAwsjson11_deserializeOpReloadReplicationTables) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpStartReplicationTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpReloadReplicationTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7280,9 +7557,9 @@ func (m *awsAwsjson11_deserializeOpStartReplicationTask) HandleDeserialize(ctx c } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorStartReplicationTask(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorReloadReplicationTables(response, &metadata) } - output := &StartReplicationTaskOutput{} + output := &ReloadReplicationTablesOutput{} out.Result = output var buff [1024]byte @@ -7302,7 +7579,7 @@ func (m *awsAwsjson11_deserializeOpStartReplicationTask) HandleDeserialize(ctx c return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentStartReplicationTaskOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentReloadReplicationTablesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7316,7 +7593,7 @@ func (m *awsAwsjson11_deserializeOpStartReplicationTask) HandleDeserialize(ctx c return out, metadata, err } -func awsAwsjson11_deserializeOpErrorStartReplicationTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorReloadReplicationTables(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7357,9 +7634,6 @@ func awsAwsjson11_deserializeOpErrorStartReplicationTask(response *smithyhttp.Re } switch { - case strings.EqualFold("AccessDeniedFault", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) - case strings.EqualFold("InvalidResourceStateFault", errorCode): return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) @@ -7376,14 +7650,14 @@ func awsAwsjson11_deserializeOpErrorStartReplicationTask(response *smithyhttp.Re } } -type awsAwsjson11_deserializeOpStartReplicationTaskAssessment struct { +type awsAwsjson11_deserializeOpReloadTables struct { } -func (*awsAwsjson11_deserializeOpStartReplicationTaskAssessment) ID() string { +func (*awsAwsjson11_deserializeOpReloadTables) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpStartReplicationTaskAssessment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpReloadTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7397,9 +7671,9 @@ func (m *awsAwsjson11_deserializeOpStartReplicationTaskAssessment) HandleDeseria } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorStartReplicationTaskAssessment(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorReloadTables(response, &metadata) } - output := &StartReplicationTaskAssessmentOutput{} + output := &ReloadTablesOutput{} out.Result = output var buff [1024]byte @@ -7419,7 +7693,7 @@ func (m *awsAwsjson11_deserializeOpStartReplicationTaskAssessment) HandleDeseria return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentStartReplicationTaskAssessmentOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentReloadTablesOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7433,7 +7707,7 @@ func (m *awsAwsjson11_deserializeOpStartReplicationTaskAssessment) HandleDeseria return out, metadata, err } -func awsAwsjson11_deserializeOpErrorStartReplicationTaskAssessment(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorReloadTables(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7490,14 +7764,14 @@ func awsAwsjson11_deserializeOpErrorStartReplicationTaskAssessment(response *smi } } -type awsAwsjson11_deserializeOpStartReplicationTaskAssessmentRun struct { +type awsAwsjson11_deserializeOpRemoveTagsFromResource struct { } -func (*awsAwsjson11_deserializeOpStartReplicationTaskAssessmentRun) ID() string { +func (*awsAwsjson11_deserializeOpRemoveTagsFromResource) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpStartReplicationTaskAssessmentRun) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpRemoveTagsFromResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7511,9 +7785,9 @@ func (m *awsAwsjson11_deserializeOpStartReplicationTaskAssessmentRun) HandleDese } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorStartReplicationTaskAssessmentRun(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorRemoveTagsFromResource(response, &metadata) } - output := &StartReplicationTaskAssessmentRunOutput{} + output := &RemoveTagsFromResourceOutput{} out.Result = output var buff [1024]byte @@ -7533,7 +7807,7 @@ func (m *awsAwsjson11_deserializeOpStartReplicationTaskAssessmentRun) HandleDese return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentStartReplicationTaskAssessmentRunOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentRemoveTagsFromResourceOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7547,7 +7821,7 @@ func (m *awsAwsjson11_deserializeOpStartReplicationTaskAssessmentRun) HandleDese return out, metadata, err } -func awsAwsjson11_deserializeOpErrorStartReplicationTaskAssessmentRun(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorRemoveTagsFromResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7588,42 +7862,9 @@ func awsAwsjson11_deserializeOpErrorStartReplicationTaskAssessmentRun(response * } switch { - case strings.EqualFold("AccessDeniedFault", errorCode): - return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) - - case strings.EqualFold("InvalidResourceStateFault", errorCode): - return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) - - case strings.EqualFold("KMSAccessDeniedFault", errorCode): - return awsAwsjson11_deserializeErrorKMSAccessDeniedFault(response, errorBody) - - case strings.EqualFold("KMSDisabledFault", errorCode): - return awsAwsjson11_deserializeErrorKMSDisabledFault(response, errorBody) - - case strings.EqualFold("KMSFault", errorCode): - return awsAwsjson11_deserializeErrorKMSFault(response, errorBody) - - case strings.EqualFold("KMSInvalidStateFault", errorCode): - return awsAwsjson11_deserializeErrorKMSInvalidStateFault(response, errorBody) - - case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): - return awsAwsjson11_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) - - case strings.EqualFold("KMSNotFoundFault", errorCode): - return awsAwsjson11_deserializeErrorKMSNotFoundFault(response, errorBody) - - case strings.EqualFold("ResourceAlreadyExistsFault", errorCode): - return awsAwsjson11_deserializeErrorResourceAlreadyExistsFault(response, errorBody) - case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) - case strings.EqualFold("S3AccessDeniedFault", errorCode): - return awsAwsjson11_deserializeErrorS3AccessDeniedFault(response, errorBody) - - case strings.EqualFold("S3ResourceNotFoundFault", errorCode): - return awsAwsjson11_deserializeErrorS3ResourceNotFoundFault(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -7634,14 +7875,14 @@ func awsAwsjson11_deserializeOpErrorStartReplicationTaskAssessmentRun(response * } } -type awsAwsjson11_deserializeOpStopReplicationTask struct { +type awsAwsjson11_deserializeOpRunFleetAdvisorLsaAnalysis struct { } -func (*awsAwsjson11_deserializeOpStopReplicationTask) ID() string { +func (*awsAwsjson11_deserializeOpRunFleetAdvisorLsaAnalysis) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpStopReplicationTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpRunFleetAdvisorLsaAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7655,9 +7896,9 @@ func (m *awsAwsjson11_deserializeOpStopReplicationTask) HandleDeserialize(ctx co } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorStopReplicationTask(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorRunFleetAdvisorLsaAnalysis(response, &metadata) } - output := &StopReplicationTaskOutput{} + output := &RunFleetAdvisorLsaAnalysisOutput{} out.Result = output var buff [1024]byte @@ -7677,7 +7918,7 @@ func (m *awsAwsjson11_deserializeOpStopReplicationTask) HandleDeserialize(ctx co return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentStopReplicationTaskOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentRunFleetAdvisorLsaAnalysisOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7691,7 +7932,7 @@ func (m *awsAwsjson11_deserializeOpStopReplicationTask) HandleDeserialize(ctx co return out, metadata, err } -func awsAwsjson11_deserializeOpErrorStopReplicationTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorRunFleetAdvisorLsaAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7748,14 +7989,14 @@ func awsAwsjson11_deserializeOpErrorStopReplicationTask(response *smithyhttp.Res } } -type awsAwsjson11_deserializeOpTestConnection struct { +type awsAwsjson11_deserializeOpStartRecommendations struct { } -func (*awsAwsjson11_deserializeOpTestConnection) ID() string { +func (*awsAwsjson11_deserializeOpStartRecommendations) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpTestConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpStartRecommendations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7769,43 +8010,21 @@ func (m *awsAwsjson11_deserializeOpTestConnection) HandleDeserialize(ctx context } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorTestConnection(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorStartRecommendations(response, &metadata) } - output := &TestConnectionOutput{} + output := &StartRecommendationsOutput{} 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_deserializeOpDocumentTestConnectionOutput(&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(), + 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 } return out, metadata, err } -func awsAwsjson11_deserializeOpErrorTestConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorStartRecommendations(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7852,15 +8071,9 @@ func awsAwsjson11_deserializeOpErrorTestConnection(response *smithyhttp.Response case strings.EqualFold("InvalidResourceStateFault", errorCode): return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) - case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): - return awsAwsjson11_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) - case strings.EqualFold("ResourceNotFoundFault", errorCode): return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) - case strings.EqualFold("ResourceQuotaExceededFault", errorCode): - return awsAwsjson11_deserializeErrorResourceQuotaExceededFault(response, errorBody) - default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -7871,14 +8084,14 @@ func awsAwsjson11_deserializeOpErrorTestConnection(response *smithyhttp.Response } } -type awsAwsjson11_deserializeOpUpdateSubscriptionsToEventBridge struct { +type awsAwsjson11_deserializeOpStartReplication struct { } -func (*awsAwsjson11_deserializeOpUpdateSubscriptionsToEventBridge) ID() string { +func (*awsAwsjson11_deserializeOpStartReplication) ID() string { return "OperationDeserializer" } -func (m *awsAwsjson11_deserializeOpUpdateSubscriptionsToEventBridge) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( +func (m *awsAwsjson11_deserializeOpStartReplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( out middleware.DeserializeOutput, metadata middleware.Metadata, err error, ) { out, metadata, err = next.HandleDeserialize(ctx, in) @@ -7892,9 +8105,9 @@ func (m *awsAwsjson11_deserializeOpUpdateSubscriptionsToEventBridge) HandleDeser } if response.StatusCode < 200 || response.StatusCode >= 300 { - return out, metadata, awsAwsjson11_deserializeOpErrorUpdateSubscriptionsToEventBridge(response, &metadata) + return out, metadata, awsAwsjson11_deserializeOpErrorStartReplication(response, &metadata) } - output := &UpdateSubscriptionsToEventBridgeOutput{} + output := &StartReplicationOutput{} out.Result = output var buff [1024]byte @@ -7914,7 +8127,7 @@ func (m *awsAwsjson11_deserializeOpUpdateSubscriptionsToEventBridge) HandleDeser return out, metadata, err } - err = awsAwsjson11_deserializeOpDocumentUpdateSubscriptionsToEventBridgeOutput(&output, shape) + err = awsAwsjson11_deserializeOpDocumentStartReplicationOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -7928,7 +8141,7 @@ func (m *awsAwsjson11_deserializeOpUpdateSubscriptionsToEventBridge) HandleDeser return out, metadata, err } -func awsAwsjson11_deserializeOpErrorUpdateSubscriptionsToEventBridge(response *smithyhttp.Response, metadata *middleware.Metadata) error { +func awsAwsjson11_deserializeOpErrorStartReplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { var errorBuffer bytes.Buffer if _, err := io.Copy(&errorBuffer, response.Body); err != nil { return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} @@ -7975,6 +8188,9 @@ func awsAwsjson11_deserializeOpErrorUpdateSubscriptionsToEventBridge(response *s case strings.EqualFold("InvalidResourceStateFault", errorCode): return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + case strings.EqualFold("ResourceNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + default: genericError := &smithy.GenericAPIError{ Code: errorCode, @@ -7985,11 +8201,36 @@ func awsAwsjson11_deserializeOpErrorUpdateSubscriptionsToEventBridge(response *s } } -func awsAwsjson11_deserializeErrorAccessDeniedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { +type awsAwsjson11_deserializeOpStartReplicationTask struct { +} + +func (*awsAwsjson11_deserializeOpStartReplicationTask) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpStartReplicationTask) HandleDeserialize(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_deserializeOpErrorStartReplicationTask(response, &metadata) + } + output := &StartReplicationTaskOutput{} + out.Result = output + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) + body := io.TeeReader(response.Body, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() var shape interface{} @@ -8000,12 +8241,10 @@ func awsAwsjson11_deserializeErrorAccessDeniedFault(response *smithyhttp.Respons Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - output := &types.AccessDeniedFault{} - err := awsAwsjson11_deserializeDocumentAccessDeniedFault(&output, shape) - + err = awsAwsjson11_deserializeOpDocumentStartReplicationTaskOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -8013,22 +8252,35 @@ func awsAwsjson11_deserializeErrorAccessDeniedFault(response *smithyhttp.Respons Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - errorBody.Seek(0, io.SeekStart) - return output + return out, metadata, err } -func awsAwsjson11_deserializeErrorCollectorNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func awsAwsjson11_deserializeOpErrorStartReplicationTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() - var shape interface{} - if err := decoder.Decode(&shape); err != nil && err != io.EOF { + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) err = &smithy.DeserializationError{ @@ -8038,28 +8290,64 @@ func awsAwsjson11_deserializeErrorCollectorNotFoundFault(response *smithyhttp.Re return err } - output := &types.CollectorNotFoundFault{} - err := awsAwsjson11_deserializeDocumentCollectorNotFoundFault(&output, shape) + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } - 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(), + switch { + case strings.EqualFold("AccessDeniedFault", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) + + case strings.EqualFold("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + + case strings.EqualFold("ResourceNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, } - return err + return genericError + } +} - errorBody.Seek(0, io.SeekStart) - return output +type awsAwsjson11_deserializeOpStartReplicationTaskAssessment struct { } -func awsAwsjson11_deserializeErrorInsufficientResourceCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { +func (*awsAwsjson11_deserializeOpStartReplicationTaskAssessment) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpStartReplicationTaskAssessment) HandleDeserialize(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_deserializeOpErrorStartReplicationTaskAssessment(response, &metadata) + } + output := &StartReplicationTaskAssessmentOutput{} + out.Result = output + var buff [1024]byte ringBuffer := smithyio.NewRingBuffer(buff[:]) - body := io.TeeReader(errorBody, ringBuffer) + body := io.TeeReader(response.Body, ringBuffer) decoder := json.NewDecoder(body) decoder.UseNumber() var shape interface{} @@ -8070,12 +8358,10 @@ func awsAwsjson11_deserializeErrorInsufficientResourceCapacityFault(response *sm Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - output := &types.InsufficientResourceCapacityFault{} - err := awsAwsjson11_deserializeDocumentInsufficientResourceCapacityFault(&output, shape) - + err = awsAwsjson11_deserializeOpDocumentStartReplicationTaskAssessmentOutput(&output, shape) if err != nil { var snapshot bytes.Buffer io.Copy(&snapshot, ringBuffer) @@ -8083,16 +8369,789 @@ func awsAwsjson11_deserializeErrorInsufficientResourceCapacityFault(response *sm Err: fmt.Errorf("failed to decode response body, %w", err), Snapshot: snapshot.Bytes(), } - return err + return out, metadata, err } - errorBody.Seek(0, io.SeekStart) - return output + return out, metadata, err } -func awsAwsjson11_deserializeErrorInvalidCertificateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { - var buff [1024]byte - ringBuffer := smithyio.NewRingBuffer(buff[:]) +func awsAwsjson11_deserializeOpErrorStartReplicationTaskAssessment(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + + case strings.EqualFold("ResourceNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpStartReplicationTaskAssessmentRun struct { +} + +func (*awsAwsjson11_deserializeOpStartReplicationTaskAssessmentRun) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpStartReplicationTaskAssessmentRun) HandleDeserialize(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_deserializeOpErrorStartReplicationTaskAssessmentRun(response, &metadata) + } + output := &StartReplicationTaskAssessmentRunOutput{} + 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_deserializeOpDocumentStartReplicationTaskAssessmentRunOutput(&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_deserializeOpErrorStartReplicationTaskAssessmentRun(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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("AccessDeniedFault", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) + + case strings.EqualFold("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + + case strings.EqualFold("KMSAccessDeniedFault", errorCode): + return awsAwsjson11_deserializeErrorKMSAccessDeniedFault(response, errorBody) + + case strings.EqualFold("KMSDisabledFault", errorCode): + return awsAwsjson11_deserializeErrorKMSDisabledFault(response, errorBody) + + case strings.EqualFold("KMSFault", errorCode): + return awsAwsjson11_deserializeErrorKMSFault(response, errorBody) + + case strings.EqualFold("KMSInvalidStateFault", errorCode): + return awsAwsjson11_deserializeErrorKMSInvalidStateFault(response, errorBody) + + case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): + return awsAwsjson11_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) + + case strings.EqualFold("KMSNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorKMSNotFoundFault(response, errorBody) + + case strings.EqualFold("ResourceAlreadyExistsFault", errorCode): + return awsAwsjson11_deserializeErrorResourceAlreadyExistsFault(response, errorBody) + + case strings.EqualFold("ResourceNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + + case strings.EqualFold("S3AccessDeniedFault", errorCode): + return awsAwsjson11_deserializeErrorS3AccessDeniedFault(response, errorBody) + + case strings.EqualFold("S3ResourceNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorS3ResourceNotFoundFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpStopReplication struct { +} + +func (*awsAwsjson11_deserializeOpStopReplication) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpStopReplication) HandleDeserialize(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_deserializeOpErrorStopReplication(response, &metadata) + } + output := &StopReplicationOutput{} + 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_deserializeOpDocumentStopReplicationOutput(&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_deserializeOpErrorStopReplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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("AccessDeniedFault", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) + + case strings.EqualFold("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + + case strings.EqualFold("ResourceNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpStopReplicationTask struct { +} + +func (*awsAwsjson11_deserializeOpStopReplicationTask) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpStopReplicationTask) HandleDeserialize(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_deserializeOpErrorStopReplicationTask(response, &metadata) + } + output := &StopReplicationTaskOutput{} + 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_deserializeOpDocumentStopReplicationTaskOutput(&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_deserializeOpErrorStopReplicationTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + + case strings.EqualFold("ResourceNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpTestConnection struct { +} + +func (*awsAwsjson11_deserializeOpTestConnection) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpTestConnection) HandleDeserialize(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_deserializeOpErrorTestConnection(response, &metadata) + } + output := &TestConnectionOutput{} + 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_deserializeOpDocumentTestConnectionOutput(&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_deserializeOpErrorTestConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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("AccessDeniedFault", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) + + case strings.EqualFold("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + + case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): + return awsAwsjson11_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) + + case strings.EqualFold("ResourceNotFoundFault", errorCode): + return awsAwsjson11_deserializeErrorResourceNotFoundFault(response, errorBody) + + case strings.EqualFold("ResourceQuotaExceededFault", errorCode): + return awsAwsjson11_deserializeErrorResourceQuotaExceededFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsAwsjson11_deserializeOpUpdateSubscriptionsToEventBridge struct { +} + +func (*awsAwsjson11_deserializeOpUpdateSubscriptionsToEventBridge) ID() string { + return "OperationDeserializer" +} + +func (m *awsAwsjson11_deserializeOpUpdateSubscriptionsToEventBridge) HandleDeserialize(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_deserializeOpErrorUpdateSubscriptionsToEventBridge(response, &metadata) + } + output := &UpdateSubscriptionsToEventBridgeOutput{} + 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_deserializeOpDocumentUpdateSubscriptionsToEventBridgeOutput(&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_deserializeOpErrorUpdateSubscriptionsToEventBridge(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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("AccessDeniedFault", errorCode): + return awsAwsjson11_deserializeErrorAccessDeniedFault(response, errorBody) + + case strings.EqualFold("InvalidResourceStateFault", errorCode): + return awsAwsjson11_deserializeErrorInvalidResourceStateFault(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +func awsAwsjson11_deserializeErrorAccessDeniedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.AccessDeniedFault{} + err := awsAwsjson11_deserializeDocumentAccessDeniedFault(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorCollectorNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.CollectorNotFoundFault{} + err := awsAwsjson11_deserializeDocumentCollectorNotFoundFault(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorInsufficientResourceCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + output := &types.InsufficientResourceCapacityFault{} + err := awsAwsjson11_deserializeDocumentInsufficientResourceCapacityFault(&output, shape) + + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + return output +} + +func awsAwsjson11_deserializeErrorInvalidCertificateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) body := io.TeeReader(errorBody, ringBuffer) decoder := json.NewDecoder(body) @@ -9633,7 +10692,90 @@ func awsAwsjson11_deserializeDocumentCollectorResponses(v *[]types.CollectorResp return nil } -func awsAwsjson11_deserializeDocumentCollectorShortInfoResponse(v **types.CollectorShortInfoResponse, value interface{}) error { +func awsAwsjson11_deserializeDocumentCollectorShortInfoResponse(v **types.CollectorShortInfoResponse, 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.CollectorShortInfoResponse + if *v == nil { + sv = &types.CollectorShortInfoResponse{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "CollectorName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.CollectorName = ptr.String(jtv) + } + + case "CollectorReferencedId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.CollectorReferencedId = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentCollectorsList(v *[]types.CollectorShortInfoResponse, 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.CollectorShortInfoResponse + if *v == nil { + cv = []types.CollectorShortInfoResponse{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.CollectorShortInfoResponse + destAddr := &col + if err := awsAwsjson11_deserializeDocumentCollectorShortInfoResponse(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentComputeConfig(v **types.ComputeConfig, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -9646,73 +10788,106 @@ func awsAwsjson11_deserializeDocumentCollectorShortInfoResponse(v **types.Collec return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.CollectorShortInfoResponse + var sv *types.ComputeConfig if *v == nil { - sv = &types.CollectorShortInfoResponse{} + sv = &types.ComputeConfig{} } else { sv = *v } for key, value := range shape { switch key { - case "CollectorName": + case "AvailabilityZone": if value != nil { jtv, ok := value.(string) if !ok { return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.CollectorName = ptr.String(jtv) + sv.AvailabilityZone = ptr.String(jtv) } - case "CollectorReferencedId": + case "DnsNameServers": if value != nil { jtv, ok := value.(string) if !ok { return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.CollectorReferencedId = ptr.String(jtv) + sv.DnsNameServers = ptr.String(jtv) } - default: - _, _ = key, value + case "KmsKeyId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.KmsKeyId = ptr.String(jtv) + } - } - } - *v = sv - return nil -} + case "MaxCapacityUnits": + 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.MaxCapacityUnits = ptr.Int32(int32(i64)) + } -func awsAwsjson11_deserializeDocumentCollectorsList(v *[]types.CollectorShortInfoResponse, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } + case "MinCapacityUnits": + 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.MinCapacityUnits = ptr.Int32(int32(i64)) + } - shape, ok := value.([]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } + case "MultiAZ": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.MultiAZ = ptr.Bool(jtv) + } - var cv []types.CollectorShortInfoResponse - if *v == nil { - cv = []types.CollectorShortInfoResponse{} - } else { - cv = *v - } + case "PreferredMaintenanceWindow": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.PreferredMaintenanceWindow = ptr.String(jtv) + } - for _, value := range shape { - var col types.CollectorShortInfoResponse - destAddr := &col - if err := awsAwsjson11_deserializeDocumentCollectorShortInfoResponse(&destAddr, value); err != nil { - return err - } - col = *destAddr - cv = append(cv, col) + case "ReplicationSubnetGroupId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ReplicationSubnetGroupId = ptr.String(jtv) + } + + case "VpcSecurityGroupIds": + if err := awsAwsjson11_deserializeDocumentStringList(&sv.VpcSecurityGroupIds, value); err != nil { + return err + } + + default: + _, _ = key, value + } } - *v = cv + *v = sv return nil } @@ -10262,6 +11437,15 @@ func awsAwsjson11_deserializeDocumentDocDbSettings(v **types.DocDbSettings, valu sv.Port = ptr.Int32(int32(i64)) } + case "ReplicateShardCollections": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.ReplicateShardCollections = ptr.Bool(jtv) + } + case "SecretsManagerAccessRoleArn": if value != nil { jtv, ok := value.(string) @@ -10298,6 +11482,15 @@ func awsAwsjson11_deserializeDocumentDocDbSettings(v **types.DocDbSettings, valu sv.Username = ptr.String(jtv) } + case "UseUpdateLookUp": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.UseUpdateLookUp = ptr.Bool(jtv) + } + default: _, _ = key, value @@ -10691,6 +11884,11 @@ func awsAwsjson11_deserializeDocumentEndpoint(v **types.Endpoint, value interfac return err } + case "TimestreamSettings": + if err := awsAwsjson11_deserializeDocumentTimestreamSettings(&sv.TimestreamSettings, value); err != nil { + return err + } + case "Username": if value != nil { jtv, ok := value.(string) @@ -12357,6 +13555,15 @@ func awsAwsjson11_deserializeDocumentKafkaSettings(v **types.KafkaSettings, valu sv.SslClientKeyPassword = ptr.String(jtv) } + case "SslEndpointIdentificationAlgorithm": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected KafkaSslEndpointIdentificationAlgorithm to be of type string, got %T instead", value) + } + sv.SslEndpointIdentificationAlgorithm = types.KafkaSslEndpointIdentificationAlgorithm(jtv) + } + case "Topic": if value != nil { jtv, ok := value.(string) @@ -13203,6 +14410,15 @@ func awsAwsjson11_deserializeDocumentMongoDbSettings(v **types.MongoDbSettings, sv.Port = ptr.Int32(int32(i64)) } + case "ReplicateShardCollections": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.ReplicateShardCollections = ptr.Bool(jtv) + } + case "SecretsManagerAccessRoleArn": if value != nil { jtv, ok := value.(string) @@ -13239,6 +14455,15 @@ func awsAwsjson11_deserializeDocumentMongoDbSettings(v **types.MongoDbSettings, sv.Username = ptr.String(jtv) } + case "UseUpdateLookUp": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.UseUpdateLookUp = ptr.Bool(jtv) + } + default: _, _ = key, value @@ -13719,6 +14944,19 @@ func awsAwsjson11_deserializeDocumentOracleSettings(v **types.OracleSettings, va sv.NumberDatatypeScale = ptr.Int32(int32(i64)) } + case "OpenTransactionWindow": + 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.OpenTransactionWindow = ptr.Int32(int32(i64)) + } + case "OraclePathPrefix": if value != nil { jtv, ok := value.(string) @@ -14416,6 +15654,24 @@ func awsAwsjson11_deserializeDocumentPostgreSQLSettings(v **types.PostgreSQLSett sv.MapBooleanAsBoolean = ptr.Bool(jtv) } + case "MapJsonbAsClob": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.MapJsonbAsClob = ptr.Bool(jtv) + } + + case "MapLongVarcharAs": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LongVarcharMappingType to be of type string, got %T instead", value) + } + sv.MapLongVarcharAs = types.LongVarcharMappingType(jtv) + } + case "MaxFileSize": if value != nil { jtv, ok := value.(json.Number) @@ -14475,43 +15731,146 @@ func awsAwsjson11_deserializeDocumentPostgreSQLSettings(v **types.PostgreSQLSett if !ok { return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.SecretsManagerSecretId = ptr.String(jtv) + sv.SecretsManagerSecretId = ptr.String(jtv) + } + + case "ServerName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ServerName = ptr.String(jtv) + } + + case "SlotName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.SlotName = ptr.String(jtv) + } + + case "TrimSpaceInChar": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.TrimSpaceInChar = ptr.Bool(jtv) + } + + case "Username": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.Username = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentProvisionData(v **types.ProvisionData, 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.ProvisionData + if *v == nil { + sv = &types.ProvisionData{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "DateNewProvisioningDataAvailable": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.DateNewProvisioningDataAvailable = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) + + } + } + + case "DateProvisioned": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.DateProvisioned = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) + + } } - case "ServerName": + case "IsNewProvisioningAvailable": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(bool) if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) } - sv.ServerName = ptr.String(jtv) + sv.IsNewProvisioningAvailable = jtv } - case "SlotName": + case "ProvisionedCapacityUnits": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) + return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) } - sv.SlotName = ptr.String(jtv) + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.ProvisionedCapacityUnits = int32(i64) } - case "TrimSpaceInChar": + case "ProvisionState": if value != nil { - jtv, ok := value.(bool) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.TrimSpaceInChar = ptr.Bool(jtv) + sv.ProvisionState = ptr.String(jtv) } - case "Username": + case "ReasonForNewProvisioningData": if value != nil { jtv, ok := value.(string) if !ok { return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.Username = ptr.String(jtv) + sv.ReasonForNewProvisioningData = ptr.String(jtv) } default: @@ -14563,6 +15922,15 @@ func awsAwsjson11_deserializeDocumentRdsConfiguration(v **types.RdsConfiguration sv.EngineEdition = ptr.String(jtv) } + case "EngineVersion": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.EngineVersion = ptr.String(jtv) + } + case "InstanceMemory": if value != nil { switch jtv := value.(type) { @@ -14765,6 +16133,15 @@ func awsAwsjson11_deserializeDocumentRdsRequirements(v **types.RdsRequirements, sv.EngineEdition = ptr.String(jtv) } + case "EngineVersion": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.EngineVersion = ptr.String(jtv) + } + case "InstanceMemory": if value != nil { switch jtv := value.(type) { @@ -15328,172 +16705,464 @@ func awsAwsjson11_deserializeDocumentRedshiftSettings(v **types.RedshiftSettings if err != nil { return err } - sv.LoadTimeout = ptr.Int32(int32(i64)) + sv.LoadTimeout = ptr.Int32(int32(i64)) + } + + case "MapBooleanAsBoolean": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.MapBooleanAsBoolean = ptr.Bool(jtv) + } + + case "MaxFileSize": + 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.MaxFileSize = ptr.Int32(int32(i64)) + } + + case "Password": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected SecretString to be of type string, got %T instead", value) + } + sv.Password = ptr.String(jtv) + } + + case "Port": + 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.Port = ptr.Int32(int32(i64)) + } + + case "RemoveQuotes": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.RemoveQuotes = ptr.Bool(jtv) + } + + case "ReplaceChars": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ReplaceChars = ptr.String(jtv) + } + + case "ReplaceInvalidChars": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ReplaceInvalidChars = ptr.String(jtv) + } + + case "SecretsManagerAccessRoleArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.SecretsManagerAccessRoleArn = ptr.String(jtv) + } + + case "SecretsManagerSecretId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.SecretsManagerSecretId = ptr.String(jtv) + } + + case "ServerName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ServerName = ptr.String(jtv) + } + + case "ServerSideEncryptionKmsKeyId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ServerSideEncryptionKmsKeyId = ptr.String(jtv) + } + + case "ServiceAccessRoleArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ServiceAccessRoleArn = ptr.String(jtv) + } + + case "TimeFormat": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.TimeFormat = ptr.String(jtv) + } + + case "TrimBlanks": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.TrimBlanks = ptr.Bool(jtv) + } + + case "TruncateColumns": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.TruncateColumns = ptr.Bool(jtv) + } + + case "Username": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.Username = ptr.String(jtv) + } + + case "WriteBufferSize": + 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.WriteBufferSize = ptr.Int32(int32(i64)) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentRefreshSchemasStatus(v **types.RefreshSchemasStatus, 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.RefreshSchemasStatus + if *v == nil { + sv = &types.RefreshSchemasStatus{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "EndpointArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.EndpointArn = ptr.String(jtv) + } + + case "LastFailureMessage": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.LastFailureMessage = ptr.String(jtv) } - case "MapBooleanAsBoolean": + case "LastRefreshDate": if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.LastRefreshDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) + } - sv.MapBooleanAsBoolean = ptr.Bool(jtv) } - case "MaxFileSize": + case "ReplicationInstanceArn": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err + return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.MaxFileSize = ptr.Int32(int32(i64)) + sv.ReplicationInstanceArn = ptr.String(jtv) } - case "Password": + case "Status": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected SecretString to be of type string, got %T instead", value) + return fmt.Errorf("expected RefreshSchemasStatusTypeValue to be of type string, got %T instead", value) } - sv.Password = ptr.String(jtv) + sv.Status = types.RefreshSchemasStatusTypeValue(jtv) } - case "Port": + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentReplication(v **types.Replication, 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.Replication + if *v == nil { + sv = &types.Replication{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "CdcStartPosition": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err + return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.Port = ptr.Int32(int32(i64)) + sv.CdcStartPosition = ptr.String(jtv) } - case "RemoveQuotes": + case "CdcStartTime": if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.CdcStartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) + } - sv.RemoveQuotes = ptr.Bool(jtv) } - case "ReplaceChars": + case "CdcStopPosition": if value != nil { jtv, ok := value.(string) if !ok { return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.ReplaceChars = ptr.String(jtv) + sv.CdcStopPosition = ptr.String(jtv) } - case "ReplaceInvalidChars": + case "FailureMessages": + if err := awsAwsjson11_deserializeDocumentStringList(&sv.FailureMessages, value); err != nil { + return err + } + + case "ProvisionData": + if err := awsAwsjson11_deserializeDocumentProvisionData(&sv.ProvisionData, value); err != nil { + return err + } + + case "RecoveryCheckpoint": if value != nil { jtv, ok := value.(string) if !ok { return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.ReplaceInvalidChars = ptr.String(jtv) + sv.RecoveryCheckpoint = ptr.String(jtv) } - case "SecretsManagerAccessRoleArn": + case "ReplicationConfigArn": if value != nil { jtv, ok := value.(string) if !ok { return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.SecretsManagerAccessRoleArn = ptr.String(jtv) + sv.ReplicationConfigArn = ptr.String(jtv) } - case "SecretsManagerSecretId": + case "ReplicationConfigIdentifier": if value != nil { jtv, ok := value.(string) if !ok { return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.SecretsManagerSecretId = ptr.String(jtv) + sv.ReplicationConfigIdentifier = ptr.String(jtv) } - case "ServerName": + case "ReplicationCreateTime": if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.ReplicationCreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) + } - sv.ServerName = ptr.String(jtv) } - case "ServerSideEncryptionKmsKeyId": + case "ReplicationLastStopTime": if value != nil { - jtv, ok := value.(string) - if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.ReplicationLastStopTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) + } - sv.ServerSideEncryptionKmsKeyId = ptr.String(jtv) } - case "ServiceAccessRoleArn": + case "ReplicationStats": + if err := awsAwsjson11_deserializeDocumentReplicationStats(&sv.ReplicationStats, value); err != nil { + return err + } + + case "ReplicationType": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) + return fmt.Errorf("expected MigrationTypeValue to be of type string, got %T instead", value) } - sv.ServiceAccessRoleArn = ptr.String(jtv) + sv.ReplicationType = types.MigrationTypeValue(jtv) } - case "TimeFormat": + case "ReplicationUpdateTime": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.ReplicationUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) + + } + } + + case "SourceEndpointArn": if value != nil { jtv, ok := value.(string) if !ok { return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.TimeFormat = ptr.String(jtv) + sv.SourceEndpointArn = ptr.String(jtv) } - case "TrimBlanks": + case "StartReplicationType": if value != nil { - jtv, ok := value.(bool) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.TrimBlanks = ptr.Bool(jtv) + sv.StartReplicationType = ptr.String(jtv) } - case "TruncateColumns": + case "Status": if value != nil { - jtv, ok := value.(bool) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.TruncateColumns = ptr.Bool(jtv) + sv.Status = ptr.String(jtv) } - case "Username": + case "StopReason": if value != nil { jtv, ok := value.(string) if !ok { return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.Username = ptr.String(jtv) + sv.StopReason = ptr.String(jtv) } - case "WriteBufferSize": + case "TargetEndpointArn": if value != nil { - jtv, ok := value.(json.Number) + jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value) - } - i64, err := jtv.Int64() - if err != nil { - return err + return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.WriteBufferSize = ptr.Int32(int32(i64)) + sv.TargetEndpointArn = ptr.String(jtv) } default: @@ -15505,7 +17174,7 @@ func awsAwsjson11_deserializeDocumentRedshiftSettings(v **types.RedshiftSettings return nil } -func awsAwsjson11_deserializeDocumentRefreshSchemasStatus(v **types.RefreshSchemasStatus, value interface{}) error { +func awsAwsjson11_deserializeDocumentReplicationConfig(v **types.ReplicationConfig, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) } @@ -15518,34 +17187,55 @@ func awsAwsjson11_deserializeDocumentRefreshSchemasStatus(v **types.RefreshSchem return fmt.Errorf("unexpected JSON type %v", value) } - var sv *types.RefreshSchemasStatus + var sv *types.ReplicationConfig if *v == nil { - sv = &types.RefreshSchemasStatus{} + sv = &types.ReplicationConfig{} } else { sv = *v } for key, value := range shape { switch key { - case "EndpointArn": + case "ComputeConfig": + if err := awsAwsjson11_deserializeDocumentComputeConfig(&sv.ComputeConfig, value); err != nil { + return err + } + + case "ReplicationConfigArn": if value != nil { jtv, ok := value.(string) if !ok { return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.EndpointArn = ptr.String(jtv) + sv.ReplicationConfigArn = ptr.String(jtv) } - case "LastFailureMessage": + case "ReplicationConfigCreateTime": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.ReplicationConfigCreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) + + } + } + + case "ReplicationConfigIdentifier": if value != nil { jtv, ok := value.(string) if !ok { return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.LastFailureMessage = ptr.String(jtv) + sv.ReplicationConfigIdentifier = ptr.String(jtv) } - case "LastRefreshDate": + case "ReplicationConfigUpdateTime": if value != nil { switch jtv := value.(type) { case json.Number: @@ -15553,7 +17243,7 @@ func awsAwsjson11_deserializeDocumentRefreshSchemasStatus(v **types.RefreshSchem if err != nil { return err } - sv.LastRefreshDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) + sv.ReplicationConfigUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) default: return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) @@ -15561,22 +17251,58 @@ func awsAwsjson11_deserializeDocumentRefreshSchemasStatus(v **types.RefreshSchem } } - case "ReplicationInstanceArn": + case "ReplicationSettings": if value != nil { jtv, ok := value.(string) if !ok { return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.ReplicationInstanceArn = ptr.String(jtv) + sv.ReplicationSettings = ptr.String(jtv) + } + + case "ReplicationType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected MigrationTypeValue to be of type string, got %T instead", value) + } + sv.ReplicationType = types.MigrationTypeValue(jtv) + } + + case "SourceEndpointArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.SourceEndpointArn = ptr.String(jtv) + } + + case "SupplementalSettings": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.SupplementalSettings = ptr.String(jtv) + } + + case "TableMappings": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.TableMappings = ptr.String(jtv) } - case "Status": + case "TargetEndpointArn": if value != nil { jtv, ok := value.(string) if !ok { - return fmt.Errorf("expected RefreshSchemasStatusTypeValue to be of type string, got %T instead", value) + return fmt.Errorf("expected String to be of type string, got %T instead", value) } - sv.Status = types.RefreshSchemasStatusTypeValue(jtv) + sv.TargetEndpointArn = ptr.String(jtv) } default: @@ -15588,6 +17314,40 @@ func awsAwsjson11_deserializeDocumentRefreshSchemasStatus(v **types.RefreshSchem return nil } +func awsAwsjson11_deserializeDocumentReplicationConfigList(v *[]types.ReplicationConfig, 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.ReplicationConfig + if *v == nil { + cv = []types.ReplicationConfig{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.ReplicationConfig + destAddr := &col + if err := awsAwsjson11_deserializeDocumentReplicationConfig(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + func awsAwsjson11_deserializeDocumentReplicationInstance(v **types.ReplicationInstance, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -16071,80 +17831,303 @@ func awsAwsjson11_deserializeDocumentReplicationInstanceTaskLogsList(v *[]types. col = *destAddr cv = append(cv, col) - } - *v = cv - return nil -} + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentReplicationList(v *[]types.Replication, 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.Replication + if *v == nil { + cv = []types.Replication{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.Replication + destAddr := &col + if err := awsAwsjson11_deserializeDocumentReplication(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentReplicationPendingModifiedValues(v **types.ReplicationPendingModifiedValues, 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.ReplicationPendingModifiedValues + if *v == nil { + sv = &types.ReplicationPendingModifiedValues{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "AllocatedStorage": + 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.AllocatedStorage = ptr.Int32(int32(i64)) + } + + case "EngineVersion": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.EngineVersion = ptr.String(jtv) + } + + case "MultiAZ": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.MultiAZ = ptr.Bool(jtv) + } + + case "NetworkType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.NetworkType = ptr.String(jtv) + } + + case "ReplicationInstanceClass": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ReplicationInstanceClass = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentReplicationStats(v **types.ReplicationStats, 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.ReplicationStats + if *v == nil { + sv = &types.ReplicationStats{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "ElapsedTimeMillis": + if value != nil { + jtv, ok := value.(json.Number) + if !ok { + return fmt.Errorf("expected Long to be json.Number, got %T instead", value) + } + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.ElapsedTimeMillis = i64 + } + + case "FreshStartDate": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.FreshStartDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) + + } + } + + case "FullLoadFinishDate": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.FullLoadFinishDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) + + } + } + + case "FullLoadProgressPercent": + 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.FullLoadProgressPercent = int32(i64) + } + + case "FullLoadStartDate": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.FullLoadStartDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) + + } + } + + case "StartDate": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.StartDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) + + } + } -func awsAwsjson11_deserializeDocumentReplicationPendingModifiedValues(v **types.ReplicationPendingModifiedValues, value interface{}) error { - if v == nil { - return fmt.Errorf("unexpected nil of type %T", v) - } - if value == nil { - return nil - } + case "StopDate": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.StopDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) - shape, ok := value.(map[string]interface{}) - if !ok { - return fmt.Errorf("unexpected JSON type %v", value) - } + default: + return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value) - var sv *types.ReplicationPendingModifiedValues - if *v == nil { - sv = &types.ReplicationPendingModifiedValues{} - } else { - sv = *v - } + } + } - for key, value := range shape { - switch key { - case "AllocatedStorage": + case "TablesErrored": if value != nil { jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value) + return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) } i64, err := jtv.Int64() if err != nil { return err } - sv.AllocatedStorage = ptr.Int32(int32(i64)) + sv.TablesErrored = int32(i64) } - case "EngineVersion": + case "TablesLoaded": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) + return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) } - sv.EngineVersion = ptr.String(jtv) - } - - case "MultiAZ": - if value != nil { - jtv, ok := value.(bool) - if !ok { - return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + i64, err := jtv.Int64() + if err != nil { + return err } - sv.MultiAZ = ptr.Bool(jtv) + sv.TablesLoaded = int32(i64) } - case "NetworkType": + case "TablesLoading": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) + return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) } - sv.NetworkType = ptr.String(jtv) + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.TablesLoading = int32(i64) } - case "ReplicationInstanceClass": + case "TablesQueued": if value != nil { - jtv, ok := value.(string) + jtv, ok := value.(json.Number) if !ok { - return fmt.Errorf("expected String to be of type string, got %T instead", value) + return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) } - sv.ReplicationInstanceClass = ptr.String(jtv) + i64, err := jtv.Int64() + if err != nil { + return err + } + sv.TablesQueued = int32(i64) } default: @@ -16307,6 +18290,40 @@ func awsAwsjson11_deserializeDocumentReplicationSubnetGroups(v *[]types.Replicat return nil } +func awsAwsjson11_deserializeDocumentReplicationTableStatisticsList(v *[]types.TableStatistics, 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.TableStatistics + if *v == nil { + cv = []types.TableStatistics{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.TableStatistics + destAddr := &col + if err := awsAwsjson11_deserializeDocumentTableStatistics(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + func awsAwsjson11_deserializeDocumentReplicationTask(v **types.ReplicationTask, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -19181,6 +21198,90 @@ func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) return nil } +func awsAwsjson11_deserializeDocumentTimestreamSettings(v **types.TimestreamSettings, 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.TimestreamSettings + if *v == nil { + sv = &types.TimestreamSettings{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "CdcInsertsAndUpdates": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.CdcInsertsAndUpdates = ptr.Bool(jtv) + } + + case "DatabaseName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.DatabaseName = ptr.String(jtv) + } + + case "EnableMagneticStoreWrites": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value) + } + sv.EnableMagneticStoreWrites = ptr.Bool(jtv) + } + + case "MagneticDuration": + 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.MagneticDuration = ptr.Int32(int32(i64)) + } + + case "MemoryDuration": + 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.MemoryDuration = ptr.Int32(int32(i64)) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeDocumentUpgradeDependencyFailureFault(v **types.UpgradeDependencyFailureFault, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -19591,6 +21692,42 @@ func awsAwsjson11_deserializeOpDocumentCreateFleetAdvisorCollectorOutput(v **Cre return nil } +func awsAwsjson11_deserializeOpDocumentCreateReplicationConfigOutput(v **CreateReplicationConfigOutput, 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 *CreateReplicationConfigOutput + if *v == nil { + sv = &CreateReplicationConfigOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "ReplicationConfig": + if err := awsAwsjson11_deserializeDocumentReplicationConfig(&sv.ReplicationConfig, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentCreateReplicationInstanceOutput(v **CreateReplicationInstanceOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -19879,6 +22016,42 @@ func awsAwsjson11_deserializeOpDocumentDeleteFleetAdvisorDatabasesOutput(v **Del return nil } +func awsAwsjson11_deserializeOpDocumentDeleteReplicationConfigOutput(v **DeleteReplicationConfigOutput, 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 *DeleteReplicationConfigOutput + if *v == nil { + sv = &DeleteReplicationConfigOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "ReplicationConfig": + if err := awsAwsjson11_deserializeDocumentReplicationConfig(&sv.ReplicationConfig, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentDeleteReplicationInstanceOutput(v **DeleteReplicationInstanceOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -20900,6 +23073,51 @@ func awsAwsjson11_deserializeOpDocumentDescribeRefreshSchemasStatusOutput(v **De return nil } +func awsAwsjson11_deserializeOpDocumentDescribeReplicationConfigsOutput(v **DescribeReplicationConfigsOutput, 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 *DescribeReplicationConfigsOutput + if *v == nil { + sv = &DescribeReplicationConfigsOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "Marker": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.Marker = ptr.String(jtv) + } + + case "ReplicationConfigs": + if err := awsAwsjson11_deserializeDocumentReplicationConfigList(&sv.ReplicationConfigs, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentDescribeReplicationInstancesOutput(v **DescribeReplicationInstancesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -20999,6 +23217,51 @@ func awsAwsjson11_deserializeOpDocumentDescribeReplicationInstanceTaskLogsOutput return nil } +func awsAwsjson11_deserializeOpDocumentDescribeReplicationsOutput(v **DescribeReplicationsOutput, 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 *DescribeReplicationsOutput + if *v == nil { + sv = &DescribeReplicationsOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "Marker": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.Marker = ptr.String(jtv) + } + + case "Replications": + if err := awsAwsjson11_deserializeDocumentReplicationList(&sv.Replications, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentDescribeReplicationSubnetGroupsOutput(v **DescribeReplicationSubnetGroupsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -21044,6 +23307,60 @@ func awsAwsjson11_deserializeOpDocumentDescribeReplicationSubnetGroupsOutput(v * return nil } +func awsAwsjson11_deserializeOpDocumentDescribeReplicationTableStatisticsOutput(v **DescribeReplicationTableStatisticsOutput, 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 *DescribeReplicationTableStatisticsOutput + if *v == nil { + sv = &DescribeReplicationTableStatisticsOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "Marker": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.Marker = ptr.String(jtv) + } + + case "ReplicationConfigArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ReplicationConfigArn = ptr.String(jtv) + } + + case "ReplicationTableStatistics": + if err := awsAwsjson11_deserializeDocumentReplicationTableStatisticsList(&sv.ReplicationTableStatistics, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentDescribeReplicationTaskAssessmentResultsOutput(v **DescribeReplicationTaskAssessmentResultsOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -21476,6 +23793,42 @@ func awsAwsjson11_deserializeOpDocumentModifyEventSubscriptionOutput(v **ModifyE return nil } +func awsAwsjson11_deserializeOpDocumentModifyReplicationConfigOutput(v **ModifyReplicationConfigOutput, 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 *ModifyReplicationConfigOutput + if *v == nil { + sv = &ModifyReplicationConfigOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "ReplicationConfig": + if err := awsAwsjson11_deserializeDocumentReplicationConfig(&sv.ReplicationConfig, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentModifyReplicationInstanceOutput(v **ModifyReplicationInstanceOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -21692,6 +24045,46 @@ func awsAwsjson11_deserializeOpDocumentRefreshSchemasOutput(v **RefreshSchemasOu return nil } +func awsAwsjson11_deserializeOpDocumentReloadReplicationTablesOutput(v **ReloadReplicationTablesOutput, 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 *ReloadReplicationTablesOutput + if *v == nil { + sv = &ReloadReplicationTablesOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "ReplicationConfigArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.ReplicationConfigArn = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentReloadTablesOutput(v **ReloadTablesOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -21812,6 +24205,42 @@ func awsAwsjson11_deserializeOpDocumentRunFleetAdvisorLsaAnalysisOutput(v **RunF return nil } +func awsAwsjson11_deserializeOpDocumentStartReplicationOutput(v **StartReplicationOutput, 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 *StartReplicationOutput + if *v == nil { + sv = &StartReplicationOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "Replication": + if err := awsAwsjson11_deserializeDocumentReplication(&sv.Replication, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentStartReplicationTaskAssessmentOutput(v **StartReplicationTaskAssessmentOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -21920,6 +24349,42 @@ func awsAwsjson11_deserializeOpDocumentStartReplicationTaskOutput(v **StartRepli return nil } +func awsAwsjson11_deserializeOpDocumentStopReplicationOutput(v **StopReplicationOutput, 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 *StopReplicationOutput + if *v == nil { + sv = &StopReplicationOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "Replication": + if err := awsAwsjson11_deserializeDocumentReplication(&sv.Replication, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeOpDocumentStopReplicationTaskOutput(v **StopReplicationTaskOutput, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) diff --git a/service/databasemigrationservice/generated.json b/service/databasemigrationservice/generated.json index e30527df1c5..101190e4e36 100644 --- a/service/databasemigrationservice/generated.json +++ b/service/databasemigrationservice/generated.json @@ -16,6 +16,7 @@ "api_op_CreateEndpoint.go", "api_op_CreateEventSubscription.go", "api_op_CreateFleetAdvisorCollector.go", + "api_op_CreateReplicationConfig.go", "api_op_CreateReplicationInstance.go", "api_op_CreateReplicationSubnetGroup.go", "api_op_CreateReplicationTask.go", @@ -25,6 +26,7 @@ "api_op_DeleteEventSubscription.go", "api_op_DeleteFleetAdvisorCollector.go", "api_op_DeleteFleetAdvisorDatabases.go", + "api_op_DeleteReplicationConfig.go", "api_op_DeleteReplicationInstance.go", "api_op_DeleteReplicationSubnetGroup.go", "api_op_DeleteReplicationTask.go", @@ -49,32 +51,39 @@ "api_op_DescribeRecommendationLimitations.go", "api_op_DescribeRecommendations.go", "api_op_DescribeRefreshSchemasStatus.go", + "api_op_DescribeReplicationConfigs.go", "api_op_DescribeReplicationInstanceTaskLogs.go", "api_op_DescribeReplicationInstances.go", "api_op_DescribeReplicationSubnetGroups.go", + "api_op_DescribeReplicationTableStatistics.go", "api_op_DescribeReplicationTaskAssessmentResults.go", "api_op_DescribeReplicationTaskAssessmentRuns.go", "api_op_DescribeReplicationTaskIndividualAssessments.go", "api_op_DescribeReplicationTasks.go", + "api_op_DescribeReplications.go", "api_op_DescribeSchemas.go", "api_op_DescribeTableStatistics.go", "api_op_ImportCertificate.go", "api_op_ListTagsForResource.go", "api_op_ModifyEndpoint.go", "api_op_ModifyEventSubscription.go", + "api_op_ModifyReplicationConfig.go", "api_op_ModifyReplicationInstance.go", "api_op_ModifyReplicationSubnetGroup.go", "api_op_ModifyReplicationTask.go", "api_op_MoveReplicationTask.go", "api_op_RebootReplicationInstance.go", "api_op_RefreshSchemas.go", + "api_op_ReloadReplicationTables.go", "api_op_ReloadTables.go", "api_op_RemoveTagsFromResource.go", "api_op_RunFleetAdvisorLsaAnalysis.go", "api_op_StartRecommendations.go", + "api_op_StartReplication.go", "api_op_StartReplicationTask.go", "api_op_StartReplicationTaskAssessment.go", "api_op_StartReplicationTaskAssessmentRun.go", + "api_op_StopReplication.go", "api_op_StopReplicationTask.go", "api_op_TestConnection.go", "api_op_UpdateSubscriptionsToEventBridge.go", diff --git a/service/databasemigrationservice/serializers.go b/service/databasemigrationservice/serializers.go index 68b3af720cb..a197e12c26d 100644 --- a/service/databasemigrationservice/serializers.go +++ b/service/databasemigrationservice/serializers.go @@ -402,6 +402,61 @@ func (m *awsAwsjson11_serializeOpCreateFleetAdvisorCollector) HandleSerialize(ct return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpCreateReplicationConfig struct { +} + +func (*awsAwsjson11_serializeOpCreateReplicationConfig) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpCreateReplicationConfig) 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.(*CreateReplicationConfigInput) + _ = 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("AmazonDMSv20160101.CreateReplicationConfig") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentCreateReplicationConfigInput(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_serializeOpCreateReplicationInstance struct { } @@ -897,6 +952,61 @@ func (m *awsAwsjson11_serializeOpDeleteFleetAdvisorDatabases) HandleSerialize(ct return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpDeleteReplicationConfig struct { +} + +func (*awsAwsjson11_serializeOpDeleteReplicationConfig) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpDeleteReplicationConfig) 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.(*DeleteReplicationConfigInput) + _ = 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("AmazonDMSv20160101.DeleteReplicationConfig") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentDeleteReplicationConfigInput(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_serializeOpDeleteReplicationInstance struct { } @@ -2217,6 +2327,61 @@ func (m *awsAwsjson11_serializeOpDescribeRefreshSchemasStatus) HandleSerialize(c return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpDescribeReplicationConfigs struct { +} + +func (*awsAwsjson11_serializeOpDescribeReplicationConfigs) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpDescribeReplicationConfigs) 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.(*DescribeReplicationConfigsInput) + _ = 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("AmazonDMSv20160101.DescribeReplicationConfigs") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentDescribeReplicationConfigsInput(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_serializeOpDescribeReplicationInstances struct { } @@ -2327,6 +2492,61 @@ func (m *awsAwsjson11_serializeOpDescribeReplicationInstanceTaskLogs) HandleSeri return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpDescribeReplications struct { +} + +func (*awsAwsjson11_serializeOpDescribeReplications) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpDescribeReplications) 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.(*DescribeReplicationsInput) + _ = 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("AmazonDMSv20160101.DescribeReplications") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentDescribeReplicationsInput(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_serializeOpDescribeReplicationSubnetGroups struct { } @@ -2382,6 +2602,61 @@ func (m *awsAwsjson11_serializeOpDescribeReplicationSubnetGroups) HandleSerializ return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpDescribeReplicationTableStatistics struct { +} + +func (*awsAwsjson11_serializeOpDescribeReplicationTableStatistics) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpDescribeReplicationTableStatistics) 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.(*DescribeReplicationTableStatisticsInput) + _ = 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("AmazonDMSv20160101.DescribeReplicationTableStatistics") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentDescribeReplicationTableStatisticsInput(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_serializeOpDescribeReplicationTaskAssessmentResults struct { } @@ -2932,6 +3207,61 @@ func (m *awsAwsjson11_serializeOpModifyEventSubscription) HandleSerialize(ctx co return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpModifyReplicationConfig struct { +} + +func (*awsAwsjson11_serializeOpModifyReplicationConfig) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpModifyReplicationConfig) 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.(*ModifyReplicationConfigInput) + _ = 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("AmazonDMSv20160101.ModifyReplicationConfig") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentModifyReplicationConfigInput(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_serializeOpModifyReplicationInstance struct { } @@ -3262,6 +3592,61 @@ func (m *awsAwsjson11_serializeOpRefreshSchemas) HandleSerialize(ctx context.Con return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpReloadReplicationTables struct { +} + +func (*awsAwsjson11_serializeOpReloadReplicationTables) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpReloadReplicationTables) 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.(*ReloadReplicationTablesInput) + _ = 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("AmazonDMSv20160101.ReloadReplicationTables") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentReloadReplicationTablesInput(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_serializeOpReloadTables struct { } @@ -3477,6 +3862,61 @@ func (m *awsAwsjson11_serializeOpStartRecommendations) HandleSerialize(ctx conte return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpStartReplication struct { +} + +func (*awsAwsjson11_serializeOpStartReplication) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpStartReplication) 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.(*StartReplicationInput) + _ = 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("AmazonDMSv20160101.StartReplication") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentStartReplicationInput(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_serializeOpStartReplicationTask struct { } @@ -3642,6 +4082,61 @@ func (m *awsAwsjson11_serializeOpStartReplicationTaskAssessmentRun) HandleSerial return next.HandleSerialize(ctx, in) } +type awsAwsjson11_serializeOpStopReplication struct { +} + +func (*awsAwsjson11_serializeOpStopReplication) ID() string { + return "OperationSerializer" +} + +func (m *awsAwsjson11_serializeOpStopReplication) 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.(*StopReplicationInput) + _ = 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("AmazonDMSv20160101.StopReplication") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsAwsjson11_serializeOpDocumentStopReplicationInput(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_serializeOpStopReplicationTask struct { } @@ -3817,6 +4312,60 @@ func awsAwsjson11_serializeDocumentArnList(v []string, value smithyjson.Value) e return nil } +func awsAwsjson11_serializeDocumentComputeConfig(v *types.ComputeConfig, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.AvailabilityZone != nil { + ok := object.Key("AvailabilityZone") + ok.String(*v.AvailabilityZone) + } + + if v.DnsNameServers != nil { + ok := object.Key("DnsNameServers") + ok.String(*v.DnsNameServers) + } + + if v.KmsKeyId != nil { + ok := object.Key("KmsKeyId") + ok.String(*v.KmsKeyId) + } + + if v.MaxCapacityUnits != nil { + ok := object.Key("MaxCapacityUnits") + ok.Integer(*v.MaxCapacityUnits) + } + + if v.MinCapacityUnits != nil { + ok := object.Key("MinCapacityUnits") + ok.Integer(*v.MinCapacityUnits) + } + + if v.MultiAZ != nil { + ok := object.Key("MultiAZ") + ok.Boolean(*v.MultiAZ) + } + + if v.PreferredMaintenanceWindow != nil { + ok := object.Key("PreferredMaintenanceWindow") + ok.String(*v.PreferredMaintenanceWindow) + } + + if v.ReplicationSubnetGroupId != nil { + ok := object.Key("ReplicationSubnetGroupId") + ok.String(*v.ReplicationSubnetGroupId) + } + + if v.VpcSecurityGroupIds != nil { + ok := object.Key("VpcSecurityGroupIds") + if err := awsAwsjson11_serializeDocumentStringList(v.VpcSecurityGroupIds, ok); err != nil { + return err + } + } + + return nil +} + func awsAwsjson11_serializeDocumentDmsTransferSettings(v *types.DmsTransferSettings, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -3873,6 +4422,11 @@ func awsAwsjson11_serializeDocumentDocDbSettings(v *types.DocDbSettings, value s ok.Integer(*v.Port) } + if v.ReplicateShardCollections != nil { + ok := object.Key("ReplicateShardCollections") + ok.Boolean(*v.ReplicateShardCollections) + } + if v.SecretsManagerAccessRoleArn != nil { ok := object.Key("SecretsManagerAccessRoleArn") ok.String(*v.SecretsManagerAccessRoleArn) @@ -3893,6 +4447,11 @@ func awsAwsjson11_serializeDocumentDocDbSettings(v *types.DocDbSettings, value s ok.String(*v.Username) } + if v.UseUpdateLookUp != nil { + ok := object.Key("UseUpdateLookUp") + ok.Boolean(*v.UseUpdateLookUp) + } + return nil } @@ -4255,6 +4814,11 @@ func awsAwsjson11_serializeDocumentKafkaSettings(v *types.KafkaSettings, value s ok.String(*v.SslClientKeyPassword) } + if len(v.SslEndpointIdentificationAlgorithm) > 0 { + ok := object.Key("SslEndpointIdentificationAlgorithm") + ok.String(string(v.SslEndpointIdentificationAlgorithm)) + } + if v.Topic != nil { ok := object.Key("Topic") ok.String(*v.Topic) @@ -4477,6 +5041,11 @@ func awsAwsjson11_serializeDocumentMongoDbSettings(v *types.MongoDbSettings, val ok.Integer(*v.Port) } + if v.ReplicateShardCollections != nil { + ok := object.Key("ReplicateShardCollections") + ok.Boolean(*v.ReplicateShardCollections) + } + if v.SecretsManagerAccessRoleArn != nil { ok := object.Key("SecretsManagerAccessRoleArn") ok.String(*v.SecretsManagerAccessRoleArn) @@ -4497,6 +5066,11 @@ func awsAwsjson11_serializeDocumentMongoDbSettings(v *types.MongoDbSettings, val ok.String(*v.Username) } + if v.UseUpdateLookUp != nil { + ok := object.Key("UseUpdateLookUp") + ok.Boolean(*v.UseUpdateLookUp) + } + return nil } @@ -4715,6 +5289,11 @@ func awsAwsjson11_serializeDocumentOracleSettings(v *types.OracleSettings, value ok.Integer(*v.NumberDatatypeScale) } + if v.OpenTransactionWindow != nil { + ok := object.Key("OpenTransactionWindow") + ok.Integer(*v.OpenTransactionWindow) + } + if v.OraclePathPrefix != nil { ok := object.Key("OraclePathPrefix") ok.String(*v.OraclePathPrefix) @@ -4892,6 +5471,16 @@ func awsAwsjson11_serializeDocumentPostgreSQLSettings(v *types.PostgreSQLSetting ok.Boolean(*v.MapBooleanAsBoolean) } + if v.MapJsonbAsClob != nil { + ok := object.Key("MapJsonbAsClob") + ok.Boolean(*v.MapJsonbAsClob) + } + + if len(v.MapLongVarcharAs) > 0 { + ok := object.Key("MapLongVarcharAs") + ok.String(string(v.MapLongVarcharAs)) + } + if v.MaxFileSize != nil { ok := object.Key("MaxFileSize") ok.Integer(*v.MaxFileSize) @@ -5550,6 +6139,38 @@ func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value return nil } +func awsAwsjson11_serializeDocumentTimestreamSettings(v *types.TimestreamSettings, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.CdcInsertsAndUpdates != nil { + ok := object.Key("CdcInsertsAndUpdates") + ok.Boolean(*v.CdcInsertsAndUpdates) + } + + if v.DatabaseName != nil { + ok := object.Key("DatabaseName") + ok.String(*v.DatabaseName) + } + + if v.EnableMagneticStoreWrites != nil { + ok := object.Key("EnableMagneticStoreWrites") + ok.Boolean(*v.EnableMagneticStoreWrites) + } + + if v.MagneticDuration != nil { + ok := object.Key("MagneticDuration") + ok.Integer(*v.MagneticDuration) + } + + if v.MemoryDuration != nil { + ok := object.Key("MemoryDuration") + ok.Integer(*v.MemoryDuration) + } + + return nil +} + func awsAwsjson11_serializeDocumentVpcSecurityGroupIdList(v []string, value smithyjson.Value) error { array := value.Array() defer array.Close() @@ -5835,6 +6456,13 @@ func awsAwsjson11_serializeOpDocumentCreateEndpointInput(v *CreateEndpointInput, } } + if v.TimestreamSettings != nil { + ok := object.Key("TimestreamSettings") + if err := awsAwsjson11_serializeDocumentTimestreamSettings(v.TimestreamSettings, ok); err != nil { + return err + } + } + if v.Username != nil { ok := object.Key("Username") ok.String(*v.Username) @@ -5918,6 +6546,67 @@ func awsAwsjson11_serializeOpDocumentCreateFleetAdvisorCollectorInput(v *CreateF return nil } +func awsAwsjson11_serializeOpDocumentCreateReplicationConfigInput(v *CreateReplicationConfigInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ComputeConfig != nil { + ok := object.Key("ComputeConfig") + if err := awsAwsjson11_serializeDocumentComputeConfig(v.ComputeConfig, ok); err != nil { + return err + } + } + + if v.ReplicationConfigIdentifier != nil { + ok := object.Key("ReplicationConfigIdentifier") + ok.String(*v.ReplicationConfigIdentifier) + } + + if v.ReplicationSettings != nil { + ok := object.Key("ReplicationSettings") + ok.String(*v.ReplicationSettings) + } + + if len(v.ReplicationType) > 0 { + ok := object.Key("ReplicationType") + ok.String(string(v.ReplicationType)) + } + + if v.ResourceIdentifier != nil { + ok := object.Key("ResourceIdentifier") + ok.String(*v.ResourceIdentifier) + } + + if v.SourceEndpointArn != nil { + ok := object.Key("SourceEndpointArn") + ok.String(*v.SourceEndpointArn) + } + + if v.SupplementalSettings != nil { + ok := object.Key("SupplementalSettings") + ok.String(*v.SupplementalSettings) + } + + if v.TableMappings != nil { + ok := object.Key("TableMappings") + ok.String(*v.TableMappings) + } + + if v.Tags != nil { + ok := object.Key("Tags") + if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil { + return err + } + } + + if v.TargetEndpointArn != nil { + ok := object.Key("TargetEndpointArn") + ok.String(*v.TargetEndpointArn) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentCreateReplicationInstanceInput(v *CreateReplicationInstanceInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -6193,6 +6882,18 @@ func awsAwsjson11_serializeOpDocumentDeleteFleetAdvisorDatabasesInput(v *DeleteF return nil } +func awsAwsjson11_serializeOpDocumentDeleteReplicationConfigInput(v *DeleteReplicationConfigInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ReplicationConfigArn != nil { + ok := object.Key("ReplicationConfigArn") + ok.String(*v.ReplicationConfigArn) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentDeleteReplicationInstanceInput(v *DeleteReplicationInstanceInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -6731,6 +7432,30 @@ func awsAwsjson11_serializeOpDocumentDescribeRefreshSchemasStatusInput(v *Descri return nil } +func awsAwsjson11_serializeOpDocumentDescribeReplicationConfigsInput(v *DescribeReplicationConfigsInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Filters != nil { + ok := object.Key("Filters") + if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil { + return err + } + } + + if v.Marker != nil { + ok := object.Key("Marker") + ok.String(*v.Marker) + } + + if v.MaxRecords != nil { + ok := object.Key("MaxRecords") + ok.Integer(*v.MaxRecords) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentDescribeReplicationInstancesInput(v *DescribeReplicationInstancesInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -6777,6 +7502,30 @@ func awsAwsjson11_serializeOpDocumentDescribeReplicationInstanceTaskLogsInput(v return nil } +func awsAwsjson11_serializeOpDocumentDescribeReplicationsInput(v *DescribeReplicationsInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Filters != nil { + ok := object.Key("Filters") + if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil { + return err + } + } + + if v.Marker != nil { + ok := object.Key("Marker") + ok.String(*v.Marker) + } + + if v.MaxRecords != nil { + ok := object.Key("MaxRecords") + ok.Integer(*v.MaxRecords) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentDescribeReplicationSubnetGroupsInput(v *DescribeReplicationSubnetGroupsInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -6801,6 +7550,35 @@ func awsAwsjson11_serializeOpDocumentDescribeReplicationSubnetGroupsInput(v *Des return nil } +func awsAwsjson11_serializeOpDocumentDescribeReplicationTableStatisticsInput(v *DescribeReplicationTableStatisticsInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Filters != nil { + ok := object.Key("Filters") + if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil { + return err + } + } + + if v.Marker != nil { + ok := object.Key("Marker") + ok.String(*v.Marker) + } + + if v.MaxRecords != nil { + ok := object.Key("MaxRecords") + ok.Integer(*v.MaxRecords) + } + + if v.ReplicationConfigArn != nil { + ok := object.Key("ReplicationConfigArn") + ok.String(*v.ReplicationConfigArn) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentDescribeReplicationTaskAssessmentResultsInput(v *DescribeReplicationTaskAssessmentResultsInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -7199,6 +7977,13 @@ func awsAwsjson11_serializeOpDocumentModifyEndpointInput(v *ModifyEndpointInput, } } + if v.TimestreamSettings != nil { + ok := object.Key("TimestreamSettings") + if err := awsAwsjson11_serializeDocumentTimestreamSettings(v.TimestreamSettings, ok); err != nil { + return err + } + } + if v.Username != nil { ok := object.Key("Username") ok.String(*v.Username) @@ -7241,6 +8026,60 @@ func awsAwsjson11_serializeOpDocumentModifyEventSubscriptionInput(v *ModifyEvent return nil } +func awsAwsjson11_serializeOpDocumentModifyReplicationConfigInput(v *ModifyReplicationConfigInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ComputeConfig != nil { + ok := object.Key("ComputeConfig") + if err := awsAwsjson11_serializeDocumentComputeConfig(v.ComputeConfig, ok); err != nil { + return err + } + } + + if v.ReplicationConfigArn != nil { + ok := object.Key("ReplicationConfigArn") + ok.String(*v.ReplicationConfigArn) + } + + if v.ReplicationConfigIdentifier != nil { + ok := object.Key("ReplicationConfigIdentifier") + ok.String(*v.ReplicationConfigIdentifier) + } + + if v.ReplicationSettings != nil { + ok := object.Key("ReplicationSettings") + ok.String(*v.ReplicationSettings) + } + + if len(v.ReplicationType) > 0 { + ok := object.Key("ReplicationType") + ok.String(string(v.ReplicationType)) + } + + if v.SourceEndpointArn != nil { + ok := object.Key("SourceEndpointArn") + ok.String(*v.SourceEndpointArn) + } + + if v.SupplementalSettings != nil { + ok := object.Key("SupplementalSettings") + ok.String(*v.SupplementalSettings) + } + + if v.TableMappings != nil { + ok := object.Key("TableMappings") + ok.String(*v.TableMappings) + } + + if v.TargetEndpointArn != nil { + ok := object.Key("TargetEndpointArn") + ok.String(*v.TargetEndpointArn) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentModifyReplicationInstanceInput(v *ModifyReplicationInstanceInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -7442,6 +8281,30 @@ func awsAwsjson11_serializeOpDocumentRefreshSchemasInput(v *RefreshSchemasInput, return nil } +func awsAwsjson11_serializeOpDocumentReloadReplicationTablesInput(v *ReloadReplicationTablesInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if len(v.ReloadOption) > 0 { + ok := object.Key("ReloadOption") + ok.String(string(v.ReloadOption)) + } + + if v.ReplicationConfigArn != nil { + ok := object.Key("ReplicationConfigArn") + ok.String(*v.ReplicationConfigArn) + } + + if v.TablesToReload != nil { + ok := object.Key("TablesToReload") + if err := awsAwsjson11_serializeDocumentTableListToReload(v.TablesToReload, ok); err != nil { + return err + } + } + + return nil +} + func awsAwsjson11_serializeOpDocumentReloadTablesInput(v *ReloadTablesInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -7504,6 +8367,38 @@ func awsAwsjson11_serializeOpDocumentStartRecommendationsInput(v *StartRecommend return nil } +func awsAwsjson11_serializeOpDocumentStartReplicationInput(v *StartReplicationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.CdcStartPosition != nil { + ok := object.Key("CdcStartPosition") + ok.String(*v.CdcStartPosition) + } + + if v.CdcStartTime != nil { + ok := object.Key("CdcStartTime") + ok.Double(smithytime.FormatEpochSeconds(*v.CdcStartTime)) + } + + if v.CdcStopPosition != nil { + ok := object.Key("CdcStopPosition") + ok.String(*v.CdcStopPosition) + } + + if v.ReplicationConfigArn != nil { + ok := object.Key("ReplicationConfigArn") + ok.String(*v.ReplicationConfigArn) + } + + if v.StartReplicationType != nil { + ok := object.Key("StartReplicationType") + ok.String(*v.StartReplicationType) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentStartReplicationTaskAssessmentInput(v *StartReplicationTaskAssessmentInput, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -7604,6 +8499,18 @@ func awsAwsjson11_serializeOpDocumentStartReplicationTaskInput(v *StartReplicati return nil } +func awsAwsjson11_serializeOpDocumentStopReplicationInput(v *StopReplicationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ReplicationConfigArn != nil { + ok := object.Key("ReplicationConfigArn") + ok.String(*v.ReplicationConfigArn) + } + + return nil +} + func awsAwsjson11_serializeOpDocumentStopReplicationTaskInput(v *StopReplicationTaskInput, value smithyjson.Value) error { object := value.Object() defer object.Close() diff --git a/service/databasemigrationservice/types/enums.go b/service/databasemigrationservice/types/enums.go index 26aecda7483..f41e78d359c 100644 --- a/service/databasemigrationservice/types/enums.go +++ b/service/databasemigrationservice/types/enums.go @@ -312,6 +312,45 @@ func (KafkaSecurityProtocol) Values() []KafkaSecurityProtocol { } } +type KafkaSslEndpointIdentificationAlgorithm string + +// Enum values for KafkaSslEndpointIdentificationAlgorithm +const ( + KafkaSslEndpointIdentificationAlgorithmNone KafkaSslEndpointIdentificationAlgorithm = "none" + KafkaSslEndpointIdentificationAlgorithmHttps KafkaSslEndpointIdentificationAlgorithm = "https" +) + +// Values returns all known values for KafkaSslEndpointIdentificationAlgorithm. +// 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 (KafkaSslEndpointIdentificationAlgorithm) Values() []KafkaSslEndpointIdentificationAlgorithm { + return []KafkaSslEndpointIdentificationAlgorithm{ + "none", + "https", + } +} + +type LongVarcharMappingType string + +// Enum values for LongVarcharMappingType +const ( + LongVarcharMappingTypeWstring LongVarcharMappingType = "wstring" + LongVarcharMappingTypeClob LongVarcharMappingType = "clob" + LongVarcharMappingTypeNclob LongVarcharMappingType = "nclob" +) + +// Values returns all known values for LongVarcharMappingType. 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 (LongVarcharMappingType) Values() []LongVarcharMappingType { + return []LongVarcharMappingType{ + "wstring", + "clob", + "nclob", + } +} + type MessageFormatValue string // Enum values for MessageFormatValue diff --git a/service/databasemigrationservice/types/errors.go b/service/databasemigrationservice/types/errors.go index baa08e5a610..762cb2cc36c 100644 --- a/service/databasemigrationservice/types/errors.go +++ b/service/databasemigrationservice/types/errors.go @@ -165,7 +165,7 @@ func (e *InvalidResourceStateFault) ErrorCode() string { } func (e *InvalidResourceStateFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } -// The subnet provided is invalid. +// The subnet provided isn't valid. type InvalidSubnet struct { Message *string diff --git a/service/databasemigrationservice/types/types.go b/service/databasemigrationservice/types/types.go index fb3f6c6b5c7..a73ad086298 100644 --- a/service/databasemigrationservice/types/types.go +++ b/service/databasemigrationservice/types/types.go @@ -174,6 +174,77 @@ type CollectorShortInfoResponse struct { noSmithyDocumentSerde } +// Configuration parameters for provisioning an DMS Serverless replication. +type ComputeConfig struct { + + // The Availability Zone where the DMS Serverless replication using this + // configuration will run. The default value is a random, system-chosen + // Availability Zone in the configuration's Amazon Web Services Region, for + // example, "us-west-2" . You can't set this parameter if the MultiAZ parameter is + // set to true . + AvailabilityZone *string + + // A list of custom DNS name servers supported for the DMS Serverless replication + // to access your source or target database. This list overrides the default name + // servers supported by the DMS Serverless replication. You can specify a + // comma-separated list of internet addresses for up to four DNS name servers. For + // example: "1.1.1.1,2.2.2.2,3.3.3.3,4.4.4.4" + DnsNameServers *string + + // An Key Management Service (KMS) key Amazon Resource Name (ARN) that is used to + // encrypt the data during DMS Serverless replication. If you don't specify a value + // for the KmsKeyId parameter, DMS uses your default encryption key. KMS creates + // the default encryption key for your Amazon Web Services account. Your Amazon Web + // Services account has a different default encryption key for each Amazon Web + // Services Region. + KmsKeyId *string + + // Specifies the maximum value of the DMS capacity units (DCUs) for which a given + // DMS Serverless replication can be provisioned. A single DCU is 2GB of RAM, with + // 2 DCUs as the minimum value allowed. The list of valid DCU values includes 2, 4, + // 8, 16, 32, 64, 128, 192, 256, and 384. So, the maximum value that you can + // specify for DMS Serverless is 384. The MaxCapacityUnits parameter is the only + // DCU parameter you are required to specify. + MaxCapacityUnits *int32 + + // Specifies the minimum value of the DMS capacity units (DCUs) for which a given + // DMS Serverless replication can be provisioned. A single DCU is 2GB of RAM, with + // 2 DCUs as the minimum value allowed. The list of valid DCU values includes 2, 4, + // 8, 16, 32, 64, 128, 192, 256, and 384. So, the minimum DCU value that you can + // specify for DMS Serverless is 2. You don't have to specify a value for the + // MinCapacityUnits parameter. If you don't set this value, DMS scans the current + // activity of available source tables to identify an optimum setting for this + // parameter. If there is no current source activity or DMS can't otherwise + // identify a more appropriate value, it sets this parameter to the minimum DCU + // value allowed, 2. + MinCapacityUnits *int32 + + // Specifies whether the DMS Serverless replication is a Multi-AZ deployment. You + // can't set the AvailabilityZone parameter if the MultiAZ parameter is set to true + // . + MultiAZ *bool + + // The weekly time range during which system maintenance can occur for the DMS + // Serverless replication, in Universal Coordinated Time (UTC). The format is + // ddd:hh24:mi-ddd:hh24:mi . The default is a 30-minute window selected at random + // from an 8-hour block of time per Amazon Web Services Region. This maintenance + // occurs on a random day of the week. Valid values for days of the week include + // Mon , Tue , Wed , Thu , Fri , Sat , and Sun . Constraints include a minimum + // 30-minute window. + PreferredMaintenanceWindow *string + + // Specifies a subnet group identifier to associate with the DMS Serverless + // replication. + ReplicationSubnetGroupId *string + + // Specifies the virtual private cloud (VPC) security group to use with the DMS + // Serverless replication. The VPC security group must work with the VPC containing + // the replication. + VpcSecurityGroupIds []string + + noSmithyDocumentSerde +} + // Status of the connection between an endpoint and a replication instance, // including Amazon Resource Names (ARNs) and the last error message issued. type Connection struct { @@ -330,6 +401,13 @@ type DocDbSettings struct { // The port value for the DocumentDB source endpoint. Port *int32 + // If true , DMS replicates data to shard collections. DMS only uses this setting + // if the target endpoint is a DocumentDB elastic cluster. When this setting is + // true , note the following: + // - You must set TargetTablePrepMode to nothing . + // - DMS automatically sets useUpdateLookup to false . + ReplicateShardCollections *bool + // The full Amazon Resource Name (ARN) of the IAM role that specifies DMS as the // trusted entity and grants the required permissions to access the value in // SecretsManagerSecret . The role must allow the iam:PassRole action. @@ -351,6 +429,12 @@ type DocDbSettings struct { // The name of the server on the DocumentDB source endpoint. ServerName *string + // If true , DMS retrieves the entire document from the DocumentDB source during + // migration. This may cause a migration failure if the server response exceeds + // bandwidth limits. To fetch only updates and deletes during migration, set this + // parameter to false . + UseUpdateLookUp *bool + // The user name you use to access the DocumentDB source endpoint. Username *string @@ -543,6 +627,10 @@ type Endpoint struct { // see the SybaseSettings structure. SybaseSettings *SybaseSettings + // The settings for the Amazon Timestream target endpoint. For more information, + // see the TimestreamSettings structure. + TimestreamSettings *TimestreamSettings + // The user name used to connect to the endpoint. Username *string @@ -961,6 +1049,10 @@ type KafkaSettings struct { // target endpoint. SslClientKeyPassword *string + // Sets hostname verification for the certificate. This setting is supported in + // DMS version 3.5.1 and later. + SslEndpointIdentificationAlgorithm KafkaSslEndpointIdentificationAlgorithm + // The topic to which you migrate the data. If you don't specify a topic, DMS // specifies "kafka-default-topic" as the migration topic. Topic *string @@ -1207,6 +1299,13 @@ type MongoDbSettings struct { // The port value for the MongoDB source endpoint. Port *int32 + // If true , DMS replicates data to shard collections. DMS only uses this setting + // if the target endpoint is a DocumentDB elastic cluster. When this setting is + // true , note the following: + // - You must set TargetTablePrepMode to nothing . + // - DMS automatically sets useUpdateLookup to false . + ReplicateShardCollections *bool + // The full Amazon Resource Name (ARN) of the IAM role that specifies DMS as the // trusted entity and grants the required permissions to access the value in // SecretsManagerSecret . The role must allow the iam:PassRole action. @@ -1228,6 +1327,12 @@ type MongoDbSettings struct { // The name of the server on the MongoDB source endpoint. ServerName *string + // If true , DMS retrieves the entire document from the MongoDB source during + // migration. This may cause a migration failure if the server response exceeds + // bandwidth limits. To fetch only updates and deletes during migration, set this + // parameter to false . + UseUpdateLookUp *bool + // The user name you use to access the MongoDB source endpoint. Username *string @@ -1490,6 +1595,12 @@ type OracleSettings struct { // Example: numberDataTypeScale=12 NumberDatatypeScale *int32 + // The timeframe in minutes to check for open transactions for a CDC-only task. + // You can specify an integer value between 0 (the default) and 240 (the maximum). + // This parameter is only valid in DMS version 3.5.0 and later. DMS supports a + // window of up to 9.5 hours including the value for OpenTransactionWindow . + OpenTransactionWindow *int32 + // Set this string attribute to the required value in order to use the Binary // Reader to capture change data for an Amazon RDS for Oracle as the source. This // value specifies the default Oracle root used to access the redo logs. @@ -1776,6 +1887,12 @@ type PostgreSQLSettings struct { // PostgreSQL migrates booleans as varchar(5) . MapBooleanAsBoolean *bool + // When true, DMS migrates JSONB values as CLOB. + MapJsonbAsClob *bool + + // When true, DMS migrates LONG values as VARCHAR. + MapLongVarcharAs LongVarcharMappingType + // Specifies the maximum size (in KB) of any .csv file used to transfer data to // PostgreSQL. Example: maxFileSize=512 MaxFileSize *int32 @@ -1824,8 +1941,9 @@ type PostgreSQLSettings struct { // the specified slot doesn't exist or the task doesn't have a valid // CdcStartPosition setting, DMS raises an error. For more information about // setting the CdcStartPosition request parameter, see Determining a CDC native - // start point in the Database Migration Service User Guide. For more information - // about using CdcStartPosition , see CreateReplicationTask (https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateReplicationTask.html) + // start point (https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Task.CDC.html#CHAP_Task.CDC.StartPoint.Native) + // in the Database Migration Service User Guide. For more information about using + // CdcStartPosition , see CreateReplicationTask (https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateReplicationTask.html) // , StartReplicationTask (https://docs.aws.amazon.com/dms/latest/APIReference/API_StartReplicationTask.html) // , and ModifyReplicationTask (https://docs.aws.amazon.com/dms/latest/APIReference/API_ModifyReplicationTask.html) // . @@ -1841,6 +1959,31 @@ type PostgreSQLSettings struct { noSmithyDocumentSerde } +// Information about provisioning resources for an DMS serverless replication. +type ProvisionData struct { + + // The timestamp when provisioning became available. + DateNewProvisioningDataAvailable *time.Time + + // The timestamp when DMS provisioned replication resources. + DateProvisioned *time.Time + + // Whether the new provisioning is available to the replication. + IsNewProvisioningAvailable bool + + // The current provisioning state + ProvisionState *string + + // The number of capacity units the replication is using. + ProvisionedCapacityUnits int32 + + // A message describing the reason that DMS provisioned new resources for the + // serverless replication. + ReasonForNewProvisioningData *string + + noSmithyDocumentSerde +} + // Provides information that describes the configuration of the recommended target // engine on Amazon RDS. type RdsConfiguration struct { @@ -1853,6 +1996,9 @@ type RdsConfiguration struct { // Describes the recommended target Amazon RDS engine edition. EngineEdition *string + // Describes the recommended target Amazon RDS engine version. + EngineVersion *string + // Describes the memory on the recommended Amazon RDS DB instance that meets your // requirements. InstanceMemory *float64 @@ -1908,6 +2054,9 @@ type RdsRequirements struct { // The required target Amazon RDS engine edition. EngineEdition *string + // The required target Amazon RDS engine version. + EngineVersion *string + // The required memory on the Amazon RDS DB instance. InstanceMemory *float64 @@ -2240,6 +2389,138 @@ type RefreshSchemasStatus struct { noSmithyDocumentSerde } +// Provides information that describes a serverless replication created by the +// CreateReplication operation. +type Replication struct { + + // Indicates the start time for a change data capture (CDC) operation. Use either + // CdcStartTime or CdcStartPosition to specify when you want a CDC operation to + // start. Specifying both values results in an error. + CdcStartPosition *string + + // Indicates the start time for a change data capture (CDC) operation. Use either + // CdcStartTime or CdcStartPosition to specify when you want a CDC operation to + // start. Specifying both values results in an error. + CdcStartTime *time.Time + + // Indicates when you want a change data capture (CDC) operation to stop. The + // value can be either server time or commit time. + CdcStopPosition *string + + // Error and other information about why a serverless replication failed. + FailureMessages []string + + // Information about provisioning resources for an DMS serverless replication. + ProvisionData *ProvisionData + + // Indicates the last checkpoint that occurred during a change data capture (CDC) + // operation. You can provide this value to the CdcStartPosition parameter to + // start a CDC operation that begins at that checkpoint. + RecoveryCheckpoint *string + + // The Amazon Resource Name for the ReplicationConfig associated with the + // replication. + ReplicationConfigArn *string + + // The identifier for the ReplicationConfig associated with the replication. + ReplicationConfigIdentifier *string + + // The time the serverless replication was created. + ReplicationCreateTime *time.Time + + // The timestamp when replication was last stopped. + ReplicationLastStopTime *time.Time + + // This object provides a collection of statistics about a serverless replication. + ReplicationStats *ReplicationStats + + // The type of the serverless replication. + ReplicationType MigrationTypeValue + + // The time the serverless replication was updated. + ReplicationUpdateTime *time.Time + + // The Amazon Resource Name for an existing Endpoint the serverless replication + // uses for its data source. + SourceEndpointArn *string + + // The replication type. + StartReplicationType *string + + // The current status of the serverless replication. + Status *string + + // The reason the replication task was stopped. This response parameter can return + // one of the following values: + // - "Stop Reason NORMAL" + // - "Stop Reason RECOVERABLE_ERROR" + // - "Stop Reason FATAL_ERROR" + // - "Stop Reason FULL_LOAD_ONLY_FINISHED" + // - "Stop Reason STOPPED_AFTER_FULL_LOAD" – Full load completed, with cached + // changes not applied + // - "Stop Reason STOPPED_AFTER_CACHED_EVENTS" – Full load completed, with cached + // changes applied + // - "Stop Reason EXPRESS_LICENSE_LIMITS_REACHED" + // - "Stop Reason STOPPED_AFTER_DDL_APPLY" – User-defined stop task after DDL + // applied + // - "Stop Reason STOPPED_DUE_TO_LOW_MEMORY" + // - "Stop Reason STOPPED_DUE_TO_LOW_DISK" + // - "Stop Reason STOPPED_AT_SERVER_TIME" – User-defined server time for stopping + // task + // - "Stop Reason STOPPED_AT_COMMIT_TIME" – User-defined commit time for stopping + // task + // - "Stop Reason RECONFIGURATION_RESTART" + // - "Stop Reason RECYCLE_TASK" + StopReason *string + + // The Amazon Resource Name for an existing Endpoint the serverless replication + // uses for its data target. + TargetEndpointArn *string + + noSmithyDocumentSerde +} + +// This object provides configuration information about a serverless replication. +type ReplicationConfig struct { + + // Configuration parameters for provisioning an DMS serverless replication. + ComputeConfig *ComputeConfig + + // The Amazon Resource Name (ARN) of this DMS Serverless replication configuration. + ReplicationConfigArn *string + + // The time the serverless replication config was created. + ReplicationConfigCreateTime *time.Time + + // The identifier for the ReplicationConfig associated with the replication. + ReplicationConfigIdentifier *string + + // The time the serverless replication config was updated. + ReplicationConfigUpdateTime *time.Time + + // Configuration parameters for an DMS serverless replication. + ReplicationSettings *string + + // The type of the replication. + ReplicationType MigrationTypeValue + + // The Amazon Resource Name (ARN) of the source endpoint for this DMS serverless + // replication configuration. + SourceEndpointArn *string + + // Additional parameters for an DMS serverless replication. + SupplementalSettings *string + + // Table mappings specified in the replication. + TableMappings *string + + // The Amazon Resource Name (ARN) of the target endpoint for this DMS serverless + // replication configuration. + TargetEndpointArn *string + + noSmithyDocumentSerde +} + // Provides information that defines a replication instance. type ReplicationInstance struct { @@ -2412,6 +2693,46 @@ type ReplicationPendingModifiedValues struct { noSmithyDocumentSerde } +// This object provides a collection of statistics about a serverless replication. +type ReplicationStats struct { + + // The elapsed time of the replication, in milliseconds. + ElapsedTimeMillis int64 + + // The date the replication was started either with a fresh start or a target + // reload. + FreshStartDate *time.Time + + // The date the replication full load was finished. + FullLoadFinishDate *time.Time + + // The percent complete for the full load serverless replication. + FullLoadProgressPercent int32 + + // The date the replication full load was started. + FullLoadStartDate *time.Time + + // The date the replication is scheduled to start. + StartDate *time.Time + + // The date the replication was stopped. + StopDate *time.Time + + // The number of errors that have occured for this replication. + TablesErrored int32 + + // The number of tables loaded for this replication. + TablesLoaded int32 + + // The number of tables currently loading for this replication. + TablesLoading int32 + + // The number of tables queued for this replication. + TablesQueued int32 + + noSmithyDocumentSerde +} + // Describes a subnet group in response to a request by the // DescribeReplicationSubnetGroups operation. type ReplicationSubnetGroup struct { @@ -2826,14 +3147,14 @@ type S3Settings struct { // UPDATE operations to .csv or .parquet (columnar storage) output files. The // default setting is false , but when CdcInsertsAndUpdates is set to true or y , // only INSERTs and UPDATEs from the source database are migrated to the .csv or - // .parquet file. For .csv file format only, how these INSERTs and UPDATEs are - // recorded depends on the value of the IncludeOpForFullLoad parameter. If - // IncludeOpForFullLoad is set to true , the first field of every CDC record is set - // to either I or U to indicate INSERT and UPDATE operations at the source. But if - // IncludeOpForFullLoad is set to false , CDC records are written without an - // indication of INSERT or UPDATE operations at the source. For more information - // about how these settings work together, see Indicating Source DB Operations in - // Migrated S3 Data (https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.S3.html#CHAP_Target.S3.Configuring.InsertOps) + // .parquet file. DMS supports the use of the .parquet files in versions 3.4.7 and + // later. How these INSERTs and UPDATEs are recorded depends on the value of the + // IncludeOpForFullLoad parameter. If IncludeOpForFullLoad is set to true , the + // first field of every CDC record is set to either I or U to indicate INSERT and + // UPDATE operations at the source. But if IncludeOpForFullLoad is set to false , + // CDC records are written without an indication of INSERT or UPDATE operations at + // the source. For more information about how these settings work together, see + // Indicating Source DB Operations in Migrated S3 Data (https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.S3.html#CHAP_Target.S3.Configuring.InsertOps) // in the Database Migration Service User Guide.. DMS supports the use of the // CdcInsertsAndUpdates parameter in versions 3.3.1 and later. CdcInsertsOnly and // CdcInsertsAndUpdates can't both be set to true for the same endpoint. Set @@ -3023,18 +3344,19 @@ type S3Settings struct { IgnoreHeaderRows *int32 // A value that enables a full load to write INSERT operations to the - // comma-separated value (.csv) output files only to indicate how the rows were - // added to the source database. DMS supports the IncludeOpForFullLoad parameter - // in versions 3.1.4 and later. For full load, records can only be inserted. By - // default (the false setting), no information is recorded in these output files - // for a full load to indicate that the rows were inserted at the source database. - // If IncludeOpForFullLoad is set to true or y , the INSERT is recorded as an I - // annotation in the first field of the .csv file. This allows the format of your - // target records from a full load to be consistent with the target records from a - // CDC load. This setting works together with the CdcInsertsOnly and the - // CdcInsertsAndUpdates parameters for output to .csv files only. For more - // information about how these settings work together, see Indicating Source DB - // Operations in Migrated S3 Data (https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.S3.html#CHAP_Target.S3.Configuring.InsertOps) + // comma-separated value (.csv) or .parquet output files only to indicate how the + // rows were added to the source database. DMS supports the IncludeOpForFullLoad + // parameter in versions 3.1.4 and later. DMS supports the use of the .parquet + // files with the IncludeOpForFullLoad parameter in versions 3.4.7 and later. For + // full load, records can only be inserted. By default (the false setting), no + // information is recorded in these output files for a full load to indicate that + // the rows were inserted at the source database. If IncludeOpForFullLoad is set + // to true or y , the INSERT is recorded as an I annotation in the first field of + // the .csv file. This allows the format of your target records from a full load to + // be consistent with the target records from a CDC load. This setting works + // together with the CdcInsertsOnly and the CdcInsertsAndUpdates parameters for + // output to .csv files only. For more information about how these settings work + // together, see Indicating Source DB Operations in Migrated S3 Data (https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.S3.html#CHAP_Target.S3.Configuring.InsertOps) // in the Database Migration Service User Guide.. IncludeOpForFullLoad *bool @@ -3459,6 +3781,48 @@ type Tag struct { noSmithyDocumentSerde } +// Provides information that defines an Amazon Timestream endpoint. +type TimestreamSettings struct { + + // Database name for the endpoint. + // + // This member is required. + DatabaseName *string + + // Set this attribute to specify the default magnetic duration applied to the + // Amazon Timestream tables in days. This is the number of days that records remain + // in magnetic store before being discarded. For more information, see Storage (https://docs.aws.amazon.com/timestream/latest/developerguide/storage.html) + // in the Amazon Timestream Developer Guide (https://docs.aws.amazon.com/timestream/latest/developerguide/) + // . + // + // This member is required. + MagneticDuration *int32 + + // Set this attribute to specify the length of time to store all of the tables in + // memory that are migrated into Amazon Timestream from the source database. Time + // is measured in units of hours. When Timestream data comes in, it first resides + // in memory for the specified duration, which allows quick access to it. + // + // This member is required. + MemoryDuration *int32 + + // Set this attribute to true to specify that DMS only applies inserts and + // updates, and not deletes. Amazon Timestream does not allow deleting records, so + // if this value is false , DMS nulls out the corresponding record in the + // Timestream database rather than deleting it. + CdcInsertsAndUpdates *bool + + // Set this attribute to true to enable memory store writes. When this value is + // false , DMS does not write records that are older in days than the value + // specified in MagneticDuration , because Amazon Timestream does not allow memory + // writes by default. For more information, see Storage (https://docs.aws.amazon.com/timestream/latest/developerguide/storage.html) + // in the Amazon Timestream Developer Guide (https://docs.aws.amazon.com/timestream/latest/developerguide/) + // . + EnableMagneticStoreWrites *bool + + noSmithyDocumentSerde +} + // Describes the status of a security group associated with the virtual private // cloud (VPC) hosting your replication and DB instances. type VpcSecurityGroupMembership struct { diff --git a/service/databasemigrationservice/validators.go b/service/databasemigrationservice/validators.go index cabfb5fd2da..9bf6e1de0a5 100644 --- a/service/databasemigrationservice/validators.go +++ b/service/databasemigrationservice/validators.go @@ -150,6 +150,26 @@ func (m *validateOpCreateFleetAdvisorCollector) HandleInitialize(ctx context.Con return next.HandleInitialize(ctx, in) } +type validateOpCreateReplicationConfig struct { +} + +func (*validateOpCreateReplicationConfig) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateReplicationConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateReplicationConfigInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateReplicationConfigInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpCreateReplicationInstance struct { } @@ -330,6 +350,26 @@ func (m *validateOpDeleteFleetAdvisorDatabases) HandleInitialize(ctx context.Con return next.HandleInitialize(ctx, in) } +type validateOpDeleteReplicationConfig struct { +} + +func (*validateOpDeleteReplicationConfig) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteReplicationConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteReplicationConfigInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteReplicationConfigInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDeleteReplicationInstance struct { } @@ -730,6 +770,26 @@ func (m *validateOpDescribeRefreshSchemasStatus) HandleInitialize(ctx context.Co return next.HandleInitialize(ctx, in) } +type validateOpDescribeReplicationConfigs struct { +} + +func (*validateOpDescribeReplicationConfigs) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDescribeReplicationConfigs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DescribeReplicationConfigsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDescribeReplicationConfigsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDescribeReplicationInstances struct { } @@ -770,6 +830,26 @@ func (m *validateOpDescribeReplicationInstanceTaskLogs) HandleInitialize(ctx con return next.HandleInitialize(ctx, in) } +type validateOpDescribeReplications struct { +} + +func (*validateOpDescribeReplications) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDescribeReplications) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DescribeReplicationsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDescribeReplicationsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDescribeReplicationSubnetGroups struct { } @@ -790,6 +870,26 @@ func (m *validateOpDescribeReplicationSubnetGroups) HandleInitialize(ctx context return next.HandleInitialize(ctx, in) } +type validateOpDescribeReplicationTableStatistics struct { +} + +func (*validateOpDescribeReplicationTableStatistics) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDescribeReplicationTableStatistics) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DescribeReplicationTableStatisticsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDescribeReplicationTableStatisticsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpDescribeReplicationTaskAssessmentRuns struct { } @@ -950,6 +1050,26 @@ func (m *validateOpModifyEventSubscription) HandleInitialize(ctx context.Context return next.HandleInitialize(ctx, in) } +type validateOpModifyReplicationConfig struct { +} + +func (*validateOpModifyReplicationConfig) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpModifyReplicationConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ModifyReplicationConfigInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpModifyReplicationConfigInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpModifyReplicationInstance struct { } @@ -1070,6 +1190,26 @@ func (m *validateOpRefreshSchemas) HandleInitialize(ctx context.Context, in midd return next.HandleInitialize(ctx, in) } +type validateOpReloadReplicationTables struct { +} + +func (*validateOpReloadReplicationTables) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpReloadReplicationTables) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ReloadReplicationTablesInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpReloadReplicationTablesInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpReloadTables struct { } @@ -1130,6 +1270,26 @@ func (m *validateOpStartRecommendations) HandleInitialize(ctx context.Context, i return next.HandleInitialize(ctx, in) } +type validateOpStartReplication struct { +} + +func (*validateOpStartReplication) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpStartReplication) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*StartReplicationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpStartReplicationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpStartReplicationTaskAssessment struct { } @@ -1190,6 +1350,26 @@ func (m *validateOpStartReplicationTask) HandleInitialize(ctx context.Context, i return next.HandleInitialize(ctx, in) } +type validateOpStopReplication struct { +} + +func (*validateOpStopReplication) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpStopReplication) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*StopReplicationInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpStopReplicationInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpStopReplicationTask struct { } @@ -1258,6 +1438,10 @@ func addOpCreateFleetAdvisorCollectorValidationMiddleware(stack *middleware.Stac return stack.Initialize.Add(&validateOpCreateFleetAdvisorCollector{}, middleware.After) } +func addOpCreateReplicationConfigValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateReplicationConfig{}, middleware.After) +} + func addOpCreateReplicationInstanceValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateReplicationInstance{}, middleware.After) } @@ -1294,6 +1478,10 @@ func addOpDeleteFleetAdvisorDatabasesValidationMiddleware(stack *middleware.Stac return stack.Initialize.Add(&validateOpDeleteFleetAdvisorDatabases{}, middleware.After) } +func addOpDeleteReplicationConfigValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteReplicationConfig{}, middleware.After) +} + func addOpDeleteReplicationInstanceValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDeleteReplicationInstance{}, middleware.After) } @@ -1374,6 +1562,10 @@ func addOpDescribeRefreshSchemasStatusValidationMiddleware(stack *middleware.Sta return stack.Initialize.Add(&validateOpDescribeRefreshSchemasStatus{}, middleware.After) } +func addOpDescribeReplicationConfigsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDescribeReplicationConfigs{}, middleware.After) +} + func addOpDescribeReplicationInstancesValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDescribeReplicationInstances{}, middleware.After) } @@ -1382,10 +1574,18 @@ func addOpDescribeReplicationInstanceTaskLogsValidationMiddleware(stack *middlew return stack.Initialize.Add(&validateOpDescribeReplicationInstanceTaskLogs{}, middleware.After) } +func addOpDescribeReplicationsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDescribeReplications{}, middleware.After) +} + func addOpDescribeReplicationSubnetGroupsValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDescribeReplicationSubnetGroups{}, middleware.After) } +func addOpDescribeReplicationTableStatisticsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDescribeReplicationTableStatistics{}, middleware.After) +} + func addOpDescribeReplicationTaskAssessmentRunsValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDescribeReplicationTaskAssessmentRuns{}, middleware.After) } @@ -1418,6 +1618,10 @@ func addOpModifyEventSubscriptionValidationMiddleware(stack *middleware.Stack) e return stack.Initialize.Add(&validateOpModifyEventSubscription{}, middleware.After) } +func addOpModifyReplicationConfigValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpModifyReplicationConfig{}, middleware.After) +} + func addOpModifyReplicationInstanceValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpModifyReplicationInstance{}, middleware.After) } @@ -1442,6 +1646,10 @@ func addOpRefreshSchemasValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpRefreshSchemas{}, middleware.After) } +func addOpReloadReplicationTablesValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpReloadReplicationTables{}, middleware.After) +} + func addOpReloadTablesValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpReloadTables{}, middleware.After) } @@ -1454,6 +1662,10 @@ func addOpStartRecommendationsValidationMiddleware(stack *middleware.Stack) erro return stack.Initialize.Add(&validateOpStartRecommendations{}, middleware.After) } +func addOpStartReplicationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpStartReplication{}, middleware.After) +} + func addOpStartReplicationTaskAssessmentValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpStartReplicationTaskAssessment{}, middleware.After) } @@ -1466,6 +1678,10 @@ func addOpStartReplicationTaskValidationMiddleware(stack *middleware.Stack) erro return stack.Initialize.Add(&validateOpStartReplicationTask{}, middleware.After) } +func addOpStopReplicationValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpStopReplication{}, middleware.After) +} + func addOpStopReplicationTaskValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpStopReplicationTask{}, middleware.After) } @@ -1667,6 +1883,27 @@ func validateTableToReload(v *types.TableToReload) error { } } +func validateTimestreamSettings(v *types.TimestreamSettings) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "TimestreamSettings"} + if v.DatabaseName == nil { + invalidParams.Add(smithy.NewErrParamRequired("DatabaseName")) + } + if v.MemoryDuration == nil { + invalidParams.Add(smithy.NewErrParamRequired("MemoryDuration")) + } + if v.MagneticDuration == nil { + invalidParams.Add(smithy.NewErrParamRequired("MagneticDuration")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpAddTagsToResourceInput(v *AddTagsToResourceInput) error { if v == nil { return nil @@ -1772,6 +2009,11 @@ func validateOpCreateEndpointInput(v *CreateEndpointInput) error { invalidParams.AddNested("RedisSettings", err.(smithy.InvalidParamsError)) } } + if v.TimestreamSettings != nil { + if err := validateTimestreamSettings(v.TimestreamSettings); err != nil { + invalidParams.AddNested("TimestreamSettings", err.(smithy.InvalidParamsError)) + } + } if invalidParams.Len() > 0 { return invalidParams } else { @@ -1818,6 +2060,36 @@ func validateOpCreateFleetAdvisorCollectorInput(v *CreateFleetAdvisorCollectorIn } } +func validateOpCreateReplicationConfigInput(v *CreateReplicationConfigInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CreateReplicationConfigInput"} + if v.ReplicationConfigIdentifier == nil { + invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigIdentifier")) + } + if v.SourceEndpointArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("SourceEndpointArn")) + } + if v.TargetEndpointArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("TargetEndpointArn")) + } + if v.ComputeConfig == nil { + invalidParams.Add(smithy.NewErrParamRequired("ComputeConfig")) + } + if len(v.ReplicationType) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("ReplicationType")) + } + if v.TableMappings == nil { + invalidParams.Add(smithy.NewErrParamRequired("TableMappings")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpCreateReplicationInstanceInput(v *CreateReplicationInstanceInput) error { if v == nil { return nil @@ -1980,6 +2252,21 @@ func validateOpDeleteFleetAdvisorDatabasesInput(v *DeleteFleetAdvisorDatabasesIn } } +func validateOpDeleteReplicationConfigInput(v *DeleteReplicationConfigInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DeleteReplicationConfigInput"} + if v.ReplicationConfigArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpDeleteReplicationInstanceInput(v *DeleteReplicationInstanceInput) error { if v == nil { return nil @@ -2308,6 +2595,23 @@ func validateOpDescribeRefreshSchemasStatusInput(v *DescribeRefreshSchemasStatus } } +func validateOpDescribeReplicationConfigsInput(v *DescribeReplicationConfigsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DescribeReplicationConfigsInput"} + 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 validateOpDescribeReplicationInstancesInput(v *DescribeReplicationInstancesInput) error { if v == nil { return nil @@ -2340,6 +2644,23 @@ func validateOpDescribeReplicationInstanceTaskLogsInput(v *DescribeReplicationIn } } +func validateOpDescribeReplicationsInput(v *DescribeReplicationsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DescribeReplicationsInput"} + 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 validateOpDescribeReplicationSubnetGroupsInput(v *DescribeReplicationSubnetGroupsInput) error { if v == nil { return nil @@ -2357,6 +2678,26 @@ func validateOpDescribeReplicationSubnetGroupsInput(v *DescribeReplicationSubnet } } +func validateOpDescribeReplicationTableStatisticsInput(v *DescribeReplicationTableStatisticsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DescribeReplicationTableStatisticsInput"} + if v.ReplicationConfigArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigArn")) + } + 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 validateOpDescribeReplicationTaskAssessmentRunsInput(v *DescribeReplicationTaskAssessmentRunsInput) error { if v == nil { return nil @@ -2486,6 +2827,11 @@ func validateOpModifyEndpointInput(v *ModifyEndpointInput) error { invalidParams.AddNested("RedisSettings", err.(smithy.InvalidParamsError)) } } + if v.TimestreamSettings != nil { + if err := validateTimestreamSettings(v.TimestreamSettings); err != nil { + invalidParams.AddNested("TimestreamSettings", err.(smithy.InvalidParamsError)) + } + } if invalidParams.Len() > 0 { return invalidParams } else { @@ -2508,6 +2854,21 @@ func validateOpModifyEventSubscriptionInput(v *ModifyEventSubscriptionInput) err } } +func validateOpModifyReplicationConfigInput(v *ModifyReplicationConfigInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ModifyReplicationConfigInput"} + if v.ReplicationConfigArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpModifyReplicationInstanceInput(v *ModifyReplicationInstanceInput) error { if v == nil { return nil @@ -2607,6 +2968,28 @@ func validateOpRefreshSchemasInput(v *RefreshSchemasInput) error { } } +func validateOpReloadReplicationTablesInput(v *ReloadReplicationTablesInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ReloadReplicationTablesInput"} + if v.ReplicationConfigArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigArn")) + } + if v.TablesToReload == nil { + invalidParams.Add(smithy.NewErrParamRequired("TablesToReload")) + } else if v.TablesToReload != nil { + if err := validateTableListToReload(v.TablesToReload); err != nil { + invalidParams.AddNested("TablesToReload", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpReloadTablesInput(v *ReloadTablesInput) error { if v == nil { return nil @@ -2669,6 +3052,24 @@ func validateOpStartRecommendationsInput(v *StartRecommendationsInput) error { } } +func validateOpStartReplicationInput(v *StartReplicationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "StartReplicationInput"} + if v.ReplicationConfigArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigArn")) + } + if v.StartReplicationType == nil { + invalidParams.Add(smithy.NewErrParamRequired("StartReplicationType")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpStartReplicationTaskAssessmentInput(v *StartReplicationTaskAssessmentInput) error { if v == nil { return nil @@ -2726,6 +3127,21 @@ func validateOpStartReplicationTaskInput(v *StartReplicationTaskInput) error { } } +func validateOpStopReplicationInput(v *StopReplicationInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "StopReplicationInput"} + if v.ReplicationConfigArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpStopReplicationTaskInput(v *StopReplicationTaskInput) error { if v == nil { return nil diff --git a/service/glue/api_op_CreateTable.go b/service/glue/api_op_CreateTable.go index 4713b23fc31..1b03a0b1e60 100644 --- a/service/glue/api_op_CreateTable.go +++ b/service/glue/api_op_CreateTable.go @@ -44,6 +44,9 @@ type CreateTableInput struct { // the Amazon Web Services account ID is used by default. CatalogId *string + // Specifies an OpenTableFormatInput structure when creating an open format table. + OpenTableFormatInput *types.OpenTableFormatInput + // A list of partition indexes, PartitionIndex structures, to create in the table. PartitionIndexes []types.PartitionIndex diff --git a/service/glue/serializers.go b/service/glue/serializers.go index 7a016388aac..97304c4624a 100644 --- a/service/glue/serializers.go +++ b/service/glue/serializers.go @@ -14884,6 +14884,23 @@ func awsAwsjson11_serializeDocumentGovernedCatalogTarget(v *types.GovernedCatalo return nil } +func awsAwsjson11_serializeDocumentIcebergInput(v *types.IcebergInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if len(v.MetadataOperation) > 0 { + ok := object.Key("MetadataOperation") + ok.String(string(v.MetadataOperation)) + } + + if v.Version != nil { + ok := object.Key("Version") + ok.String(*v.Version) + } + + return nil +} + func awsAwsjson11_serializeDocumentIcebergTarget(v *types.IcebergTarget, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -16201,6 +16218,20 @@ func awsAwsjson11_serializeDocumentOneInput(v []string, value smithyjson.Value) return nil } +func awsAwsjson11_serializeDocumentOpenTableFormatInput(v *types.OpenTableFormatInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.IcebergInput != nil { + ok := object.Key("IcebergInput") + if err := awsAwsjson11_serializeDocumentIcebergInput(v.IcebergInput, ok); err != nil { + return err + } + } + + return nil +} + func awsAwsjson11_serializeDocumentOption(v *types.Option, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -20553,6 +20584,13 @@ func awsAwsjson11_serializeOpDocumentCreateTableInput(v *CreateTableInput, value ok.String(*v.DatabaseName) } + if v.OpenTableFormatInput != nil { + ok := object.Key("OpenTableFormatInput") + if err := awsAwsjson11_serializeDocumentOpenTableFormatInput(v.OpenTableFormatInput, ok); err != nil { + return err + } + } + if v.PartitionIndexes != nil { ok := object.Key("PartitionIndexes") if err := awsAwsjson11_serializeDocumentPartitionIndexList(v.PartitionIndexes, ok); err != nil { diff --git a/service/glue/types/enums.go b/service/glue/types/enums.go index 71f97280730..c44352443e9 100644 --- a/service/glue/types/enums.go +++ b/service/glue/types/enums.go @@ -1120,6 +1120,22 @@ func (LogicalOperator) Values() []LogicalOperator { } } +type MetadataOperation string + +// Enum values for MetadataOperation +const ( + MetadataOperationCreate MetadataOperation = "CREATE" +) + +// Values returns all known values for MetadataOperation. 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 (MetadataOperation) Values() []MetadataOperation { + return []MetadataOperation{ + "CREATE", + } +} + type MLUserDataEncryptionModeString string // Enum values for MLUserDataEncryptionModeString diff --git a/service/glue/types/types.go b/service/glue/types/types.go index d51f134dfa4..e4d59c9e86b 100644 --- a/service/glue/types/types.go +++ b/service/glue/types/types.go @@ -3471,6 +3471,21 @@ type GrokClassifier struct { noSmithyDocumentSerde } +// A structure that defines an Apache Iceberg metadata table to create in the +// catalog. +type IcebergInput struct { + + // A required metadata operation. Can only be set to CREATE . + // + // This member is required. + MetadataOperation MetadataOperation + + // The table version for the Iceberg table. Defaults to 2. + Version *string + + noSmithyDocumentSerde +} + // Specifies an Apache Iceberg data source where Iceberg tables are stored in // Amazon S3. type IcebergTarget struct { @@ -5033,6 +5048,16 @@ type NullValueField struct { noSmithyDocumentSerde } +// A structure representing an open format table. +type OpenTableFormatInput struct { + + // Specifies an IcebergInput structure that defines an Apache Iceberg metadata + // table. + IcebergInput *IcebergInput + + noSmithyDocumentSerde +} + // Specifies an option value. type Option struct { diff --git a/service/glue/validators.go b/service/glue/validators.go index 3f419af87ef..1081a714630 100644 --- a/service/glue/validators.go +++ b/service/glue/validators.go @@ -6017,6 +6017,21 @@ func validateGovernedCatalogTarget(v *types.GovernedCatalogTarget) error { } } +func validateIcebergInput(v *types.IcebergInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "IcebergInput"} + if len(v.MetadataOperation) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("MetadataOperation")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateJDBCConnectorSource(v *types.JDBCConnectorSource) error { if v == nil { return nil @@ -6368,6 +6383,23 @@ func validateNullValueFields(v []types.NullValueField) error { } } +func validateOpenTableFormatInput(v *types.OpenTableFormatInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "OpenTableFormatInput"} + if v.IcebergInput != nil { + if err := validateIcebergInput(v.IcebergInput); err != nil { + invalidParams.AddNested("IcebergInput", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOracleSQLCatalogSource(v *types.OracleSQLCatalogSource) error { if v == nil { return nil @@ -8330,6 +8362,11 @@ func validateOpCreateTableInput(v *CreateTableInput) error { invalidParams.AddNested("PartitionIndexes", err.(smithy.InvalidParamsError)) } } + if v.OpenTableFormatInput != nil { + if err := validateOpenTableFormatInput(v.OpenTableFormatInput); err != nil { + invalidParams.AddNested("OpenTableFormatInput", err.(smithy.InvalidParamsError)) + } + } if invalidParams.Len() > 0 { return invalidParams } else { diff --git a/service/medialive/api_op_DescribeAccountConfiguration.go b/service/medialive/api_op_DescribeAccountConfiguration.go new file mode 100644 index 00000000000..9b485998e0a --- /dev/null +++ b/service/medialive/api_op_DescribeAccountConfiguration.go @@ -0,0 +1,117 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package medialive + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/medialive/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Get account configuration +func (c *Client) DescribeAccountConfiguration(ctx context.Context, params *DescribeAccountConfigurationInput, optFns ...func(*Options)) (*DescribeAccountConfigurationOutput, error) { + if params == nil { + params = &DescribeAccountConfigurationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeAccountConfiguration", params, optFns, c.addOperationDescribeAccountConfigurationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeAccountConfigurationOutput) + out.ResultMetadata = metadata + return out, nil +} + +// Placeholder documentation for DescribeAccountConfigurationRequest +type DescribeAccountConfigurationInput struct { + noSmithyDocumentSerde +} + +// Placeholder documentation for DescribeAccountConfigurationResponse +type DescribeAccountConfigurationOutput struct { + + // Placeholder documentation for AccountConfiguration + AccountConfiguration *types.AccountConfiguration + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeAccountConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeAccountConfiguration{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeAccountConfiguration{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAccountConfiguration(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 + } + return nil +} + +func newServiceMetadataMiddleware_opDescribeAccountConfiguration(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "medialive", + OperationName: "DescribeAccountConfiguration", + } +} diff --git a/service/medialive/api_op_DescribeThumbnails.go b/service/medialive/api_op_DescribeThumbnails.go new file mode 100644 index 00000000000..ef5edf802e7 --- /dev/null +++ b/service/medialive/api_op_DescribeThumbnails.go @@ -0,0 +1,136 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package medialive + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/medialive/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Describe the latest thumbnails data. +func (c *Client) DescribeThumbnails(ctx context.Context, params *DescribeThumbnailsInput, optFns ...func(*Options)) (*DescribeThumbnailsOutput, error) { + if params == nil { + params = &DescribeThumbnailsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeThumbnails", params, optFns, c.addOperationDescribeThumbnailsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeThumbnailsOutput) + out.ResultMetadata = metadata + return out, nil +} + +// Placeholder documentation for DescribeThumbnailsRequest +type DescribeThumbnailsInput struct { + + // Unique ID of the channel + // + // This member is required. + ChannelId *string + + // Pipeline ID ("0" or "1") + // + // This member is required. + PipelineId *string + + // thumbnail type + // + // This member is required. + ThumbnailType *string + + noSmithyDocumentSerde +} + +// Placeholder documentation for DescribeThumbnailsResponse +type DescribeThumbnailsOutput struct { + + // Placeholder documentation for __listOfThumbnailDetail + ThumbnailDetails []types.ThumbnailDetail + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationDescribeThumbnailsMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeThumbnails{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeThumbnails{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpDescribeThumbnailsValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeThumbnails(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 + } + return nil +} + +func newServiceMetadataMiddleware_opDescribeThumbnails(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "medialive", + OperationName: "DescribeThumbnails", + } +} diff --git a/service/medialive/api_op_UpdateAccountConfiguration.go b/service/medialive/api_op_UpdateAccountConfiguration.go new file mode 100644 index 00000000000..32abac21497 --- /dev/null +++ b/service/medialive/api_op_UpdateAccountConfiguration.go @@ -0,0 +1,121 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package medialive + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/service/medialive/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Update account configuration +func (c *Client) UpdateAccountConfiguration(ctx context.Context, params *UpdateAccountConfigurationInput, optFns ...func(*Options)) (*UpdateAccountConfigurationOutput, error) { + if params == nil { + params = &UpdateAccountConfigurationInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "UpdateAccountConfiguration", params, optFns, c.addOperationUpdateAccountConfigurationMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*UpdateAccountConfigurationOutput) + out.ResultMetadata = metadata + return out, nil +} + +// List of account configuration parameters to update. +type UpdateAccountConfigurationInput struct { + + // Placeholder documentation for AccountConfiguration + AccountConfiguration *types.AccountConfiguration + + noSmithyDocumentSerde +} + +// Placeholder documentation for UpdateAccountConfigurationResponse +type UpdateAccountConfigurationOutput struct { + + // Placeholder documentation for AccountConfiguration + AccountConfiguration *types.AccountConfiguration + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationUpdateAccountConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateAccountConfiguration{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateAccountConfiguration{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateAccountConfiguration(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 + } + return nil +} + +func newServiceMetadataMiddleware_opUpdateAccountConfiguration(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "medialive", + OperationName: "UpdateAccountConfiguration", + } +} diff --git a/service/medialive/deserializers.go b/service/medialive/deserializers.go index 426a9134d7a..f75e18c1496 100644 --- a/service/medialive/deserializers.go +++ b/service/medialive/deserializers.go @@ -3634,6 +3634,168 @@ func awsRestjson1_deserializeOpErrorDeleteTags(response *smithyhttp.Response, me } } +type awsRestjson1_deserializeOpDescribeAccountConfiguration struct { +} + +func (*awsRestjson1_deserializeOpDescribeAccountConfiguration) ID() string { + return "OperationDeserializer" +} + +func (m *awsRestjson1_deserializeOpDescribeAccountConfiguration) HandleDeserialize(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_deserializeOpErrorDescribeAccountConfiguration(response, &metadata) + } + output := &DescribeAccountConfigurationOutput{} + 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 = awsRestjson1_deserializeOpDocumentDescribeAccountConfigurationOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return out, metadata, err +} + +func awsRestjson1_deserializeOpErrorDescribeAccountConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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("BadGatewayException", errorCode): + return awsRestjson1_deserializeErrorBadGatewayException(response, errorBody) + + case strings.EqualFold("BadRequestException", errorCode): + return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) + + case strings.EqualFold("ForbiddenException", errorCode): + return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) + + case strings.EqualFold("GatewayTimeoutException", errorCode): + return awsRestjson1_deserializeErrorGatewayTimeoutException(response, errorBody) + + case strings.EqualFold("InternalServerErrorException", errorCode): + return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) + + case strings.EqualFold("TooManyRequestsException", errorCode): + return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +func awsRestjson1_deserializeOpDocumentDescribeAccountConfigurationOutput(v **DescribeAccountConfigurationOutput, 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 *DescribeAccountConfigurationOutput + if *v == nil { + sv = &DescribeAccountConfigurationOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "accountConfiguration": + if err := awsRestjson1_deserializeDocumentAccountConfiguration(&sv.AccountConfiguration, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + type awsRestjson1_deserializeOpDescribeChannel struct { } @@ -6105,6 +6267,174 @@ func awsRestjson1_deserializeOpDocumentDescribeScheduleOutput(v **DescribeSchedu return nil } +type awsRestjson1_deserializeOpDescribeThumbnails struct { +} + +func (*awsRestjson1_deserializeOpDescribeThumbnails) ID() string { + return "OperationDeserializer" +} + +func (m *awsRestjson1_deserializeOpDescribeThumbnails) HandleDeserialize(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_deserializeOpErrorDescribeThumbnails(response, &metadata) + } + output := &DescribeThumbnailsOutput{} + 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 = awsRestjson1_deserializeOpDocumentDescribeThumbnailsOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return out, metadata, err +} + +func awsRestjson1_deserializeOpErrorDescribeThumbnails(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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("BadGatewayException", errorCode): + return awsRestjson1_deserializeErrorBadGatewayException(response, errorBody) + + case strings.EqualFold("BadRequestException", errorCode): + return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) + + case strings.EqualFold("ConflictException", errorCode): + return awsRestjson1_deserializeErrorConflictException(response, errorBody) + + case strings.EqualFold("ForbiddenException", errorCode): + return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) + + case strings.EqualFold("GatewayTimeoutException", errorCode): + return awsRestjson1_deserializeErrorGatewayTimeoutException(response, errorBody) + + case strings.EqualFold("InternalServerErrorException", errorCode): + return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) + + case strings.EqualFold("NotFoundException", errorCode): + return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) + + case strings.EqualFold("TooManyRequestsException", errorCode): + return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +func awsRestjson1_deserializeOpDocumentDescribeThumbnailsOutput(v **DescribeThumbnailsOutput, 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 *DescribeThumbnailsOutput + if *v == nil { + sv = &DescribeThumbnailsOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "thumbnailDetails": + if err := awsRestjson1_deserializeDocument__listOfThumbnailDetail(&sv.ThumbnailDetails, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + type awsRestjson1_deserializeOpListChannels struct { } @@ -9445,23 +9775,188 @@ func awsRestjson1_deserializeOpErrorTransferInputDevice(response *smithyhttp.Res case strings.EqualFold("InternalServerErrorException", errorCode): return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) - case strings.EqualFold("NotFoundException", errorCode): - return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) + case strings.EqualFold("NotFoundException", errorCode): + return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) + + case strings.EqualFold("TooManyRequestsException", errorCode): + return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) + + case strings.EqualFold("UnprocessableEntityException", errorCode): + return awsRestjson1_deserializeErrorUnprocessableEntityException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +type awsRestjson1_deserializeOpUpdateAccountConfiguration struct { +} + +func (*awsRestjson1_deserializeOpUpdateAccountConfiguration) ID() string { + return "OperationDeserializer" +} + +func (m *awsRestjson1_deserializeOpUpdateAccountConfiguration) HandleDeserialize(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_deserializeOpErrorUpdateAccountConfiguration(response, &metadata) + } + output := &UpdateAccountConfigurationOutput{} + 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 = awsRestjson1_deserializeOpDocumentUpdateAccountConfigurationOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return out, metadata, err +} + +func awsRestjson1_deserializeOpErrorUpdateAccountConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.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("BadGatewayException", errorCode): + return awsRestjson1_deserializeErrorBadGatewayException(response, errorBody) + + case strings.EqualFold("BadRequestException", errorCode): + return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) + + case strings.EqualFold("ForbiddenException", errorCode): + return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) + + case strings.EqualFold("GatewayTimeoutException", errorCode): + return awsRestjson1_deserializeErrorGatewayTimeoutException(response, errorBody) + + case strings.EqualFold("InternalServerErrorException", errorCode): + return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) + + case strings.EqualFold("TooManyRequestsException", errorCode): + return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) + + case strings.EqualFold("UnprocessableEntityException", errorCode): + return awsRestjson1_deserializeErrorUnprocessableEntityException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +func awsRestjson1_deserializeOpDocumentUpdateAccountConfigurationOutput(v **UpdateAccountConfigurationOutput, 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 *UpdateAccountConfigurationOutput + if *v == nil { + sv = &UpdateAccountConfigurationOutput{} + } else { + sv = *v + } - case strings.EqualFold("TooManyRequestsException", errorCode): - return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) + for key, value := range shape { + switch key { + case "accountConfiguration": + if err := awsRestjson1_deserializeDocumentAccountConfiguration(&sv.AccountConfiguration, value); err != nil { + return err + } - case strings.EqualFold("UnprocessableEntityException", errorCode): - return awsRestjson1_deserializeErrorUnprocessableEntityException(response, errorBody) + default: + _, _ = key, value - default: - genericError := &smithy.GenericAPIError{ - Code: errorCode, - Message: errorMessage, } - return genericError - } + *v = sv + return nil } type awsRestjson1_deserializeOpUpdateChannel struct { @@ -12628,6 +13123,74 @@ func awsRestjson1_deserializeDocument__listOfScte35Descriptor(v *[]types.Scte35D return nil } +func awsRestjson1_deserializeDocument__listOfThumbnail(v *[]types.Thumbnail, 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.Thumbnail + if *v == nil { + cv = []types.Thumbnail{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.Thumbnail + destAddr := &col + if err := awsRestjson1_deserializeDocumentThumbnail(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsRestjson1_deserializeDocument__listOfThumbnailDetail(v *[]types.ThumbnailDetail, 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.ThumbnailDetail + if *v == nil { + cv = []types.ThumbnailDetail{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.ThumbnailDetail + destAddr := &col + if err := awsRestjson1_deserializeDocumentThumbnailDetail(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + func awsRestjson1_deserializeDocument__listOfTransferringInputDeviceSummary(v *[]types.TransferringInputDeviceSummary, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -13015,6 +13578,46 @@ func awsRestjson1_deserializeDocumentAc3Settings(v **types.Ac3Settings, value in return nil } +func awsRestjson1_deserializeDocumentAccountConfiguration(v **types.AccountConfiguration, 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.AccountConfiguration + if *v == nil { + sv = &types.AccountConfiguration{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "kmsKeyId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected __string to be of type string, got %T instead", value) + } + sv.KmsKeyId = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsRestjson1_deserializeDocumentAncillarySourceSettings(v **types.AncillarySourceSettings, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -17179,6 +17782,11 @@ func awsRestjson1_deserializeDocumentEncoderSettings(v **types.EncoderSettings, return err } + case "thumbnailConfiguration": + if err := awsRestjson1_deserializeDocumentThumbnailConfiguration(&sv.ThumbnailConfiguration, value); err != nil { + return err + } + case "timecodeConfig": if err := awsRestjson1_deserializeDocumentTimecodeConfig(&sv.TimecodeConfig, value); err != nil { return err @@ -28378,6 +28986,162 @@ func awsRestjson1_deserializeDocumentTemporalFilterSettings(v **types.TemporalFi return nil } +func awsRestjson1_deserializeDocumentThumbnail(v **types.Thumbnail, 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.Thumbnail + if *v == nil { + sv = &types.Thumbnail{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "body": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected __string to be of type string, got %T instead", value) + } + sv.Body = ptr.String(jtv) + } + + case "contentType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected __string to be of type string, got %T instead", value) + } + sv.ContentType = ptr.String(jtv) + } + + case "thumbnailType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ThumbnailType to be of type string, got %T instead", value) + } + sv.ThumbnailType = types.ThumbnailType(jtv) + } + + case "timeStamp": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) + } + t, err := smithytime.ParseDateTime(jtv) + if err != nil { + return err + } + sv.TimeStamp = ptr.Time(t) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsRestjson1_deserializeDocumentThumbnailConfiguration(v **types.ThumbnailConfiguration, 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.ThumbnailConfiguration + if *v == nil { + sv = &types.ThumbnailConfiguration{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "state": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ThumbnailState to be of type string, got %T instead", value) + } + sv.State = types.ThumbnailState(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsRestjson1_deserializeDocumentThumbnailDetail(v **types.ThumbnailDetail, 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.ThumbnailDetail + if *v == nil { + sv = &types.ThumbnailDetail{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "pipelineId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected __string to be of type string, got %T instead", value) + } + sv.PipelineId = ptr.String(jtv) + } + + case "thumbnails": + if err := awsRestjson1_deserializeDocument__listOfThumbnail(&sv.Thumbnails, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsRestjson1_deserializeDocumentTimecodeBurninSettings(v **types.TimecodeBurninSettings, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) diff --git a/service/medialive/generated.json b/service/medialive/generated.json index 9d7cf6edc20..80841ca52e4 100644 --- a/service/medialive/generated.json +++ b/service/medialive/generated.json @@ -31,6 +31,7 @@ "api_op_DeleteReservation.go", "api_op_DeleteSchedule.go", "api_op_DeleteTags.go", + "api_op_DescribeAccountConfiguration.go", "api_op_DescribeChannel.go", "api_op_DescribeInput.go", "api_op_DescribeInputDevice.go", @@ -41,6 +42,7 @@ "api_op_DescribeOffering.go", "api_op_DescribeReservation.go", "api_op_DescribeSchedule.go", + "api_op_DescribeThumbnails.go", "api_op_ListChannels.go", "api_op_ListInputDeviceTransfers.go", "api_op_ListInputDevices.go", @@ -60,6 +62,7 @@ "api_op_StopChannel.go", "api_op_StopMultiplex.go", "api_op_TransferInputDevice.go", + "api_op_UpdateAccountConfiguration.go", "api_op_UpdateChannel.go", "api_op_UpdateChannelClass.go", "api_op_UpdateInput.go", diff --git a/service/medialive/serializers.go b/service/medialive/serializers.go index 661c9b7f739..769620cd421 100644 --- a/service/medialive/serializers.go +++ b/service/medialive/serializers.go @@ -1729,6 +1729,51 @@ func awsRestjson1_serializeOpHttpBindingsDeleteTagsInput(v *DeleteTagsInput, enc return nil } +type awsRestjson1_serializeOpDescribeAccountConfiguration struct { +} + +func (*awsRestjson1_serializeOpDescribeAccountConfiguration) ID() string { + return "OperationSerializer" +} + +func (m *awsRestjson1_serializeOpDescribeAccountConfiguration) 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.(*DescribeAccountConfigurationInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + opPath, opQuery := httpbinding.SplitURI("/prod/accountConfiguration") + request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) + request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) + request.Method = "GET" + restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if 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_serializeOpHttpBindingsDescribeAccountConfigurationInput(v *DescribeAccountConfigurationInput, encoder *httpbinding.Encoder) error { + if v == nil { + return fmt.Errorf("unsupported serialization of nil %T", v) + } + + return nil +} + type awsRestjson1_serializeOpDescribeChannel struct { } @@ -2331,6 +2376,72 @@ func awsRestjson1_serializeOpHttpBindingsDescribeScheduleInput(v *DescribeSchedu return nil } +type awsRestjson1_serializeOpDescribeThumbnails struct { +} + +func (*awsRestjson1_serializeOpDescribeThumbnails) ID() string { + return "OperationSerializer" +} + +func (m *awsRestjson1_serializeOpDescribeThumbnails) 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.(*DescribeThumbnailsInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + opPath, opQuery := httpbinding.SplitURI("/prod/channels/{ChannelId}/thumbnails") + request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) + request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) + request.Method = "GET" + restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if err := awsRestjson1_serializeOpHttpBindingsDescribeThumbnailsInput(input, restEncoder); 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_serializeOpHttpBindingsDescribeThumbnailsInput(v *DescribeThumbnailsInput, encoder *httpbinding.Encoder) error { + if v == nil { + return fmt.Errorf("unsupported serialization of nil %T", v) + } + + if v.ChannelId == nil || len(*v.ChannelId) == 0 { + return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelId must not be empty")} + } + if v.ChannelId != nil { + if err := encoder.SetURI("ChannelId").String(*v.ChannelId); err != nil { + return err + } + } + + if v.PipelineId != nil { + encoder.SetQuery("pipelineId").String(*v.PipelineId) + } + + if v.ThumbnailType != nil { + encoder.SetQuery("thumbnailType").String(*v.ThumbnailType) + } + + return nil +} + type awsRestjson1_serializeOpListChannels struct { } @@ -3617,6 +3728,76 @@ func awsRestjson1_serializeOpDocumentTransferInputDeviceInput(v *TransferInputDe return nil } +type awsRestjson1_serializeOpUpdateAccountConfiguration struct { +} + +func (*awsRestjson1_serializeOpUpdateAccountConfiguration) ID() string { + return "OperationSerializer" +} + +func (m *awsRestjson1_serializeOpUpdateAccountConfiguration) 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.(*UpdateAccountConfigurationInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + opPath, opQuery := httpbinding.SplitURI("/prod/accountConfiguration") + request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) + request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) + request.Method = "PUT" + restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + restEncoder.SetHeader("Content-Type").String("application/json") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsRestjson1_serializeOpDocumentUpdateAccountConfigurationInput(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_serializeOpHttpBindingsUpdateAccountConfigurationInput(v *UpdateAccountConfigurationInput, encoder *httpbinding.Encoder) error { + if v == nil { + return fmt.Errorf("unsupported serialization of nil %T", v) + } + + return nil +} + +func awsRestjson1_serializeOpDocumentUpdateAccountConfigurationInput(v *UpdateAccountConfigurationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.AccountConfiguration != nil { + ok := object.Key("accountConfiguration") + if err := awsRestjson1_serializeDocumentAccountConfiguration(v.AccountConfiguration, ok); err != nil { + return err + } + } + + return nil +} + type awsRestjson1_serializeOpUpdateChannel struct { } @@ -4903,6 +5084,18 @@ func awsRestjson1_serializeDocumentAc3Settings(v *types.Ac3Settings, value smith return nil } +func awsRestjson1_serializeDocumentAccountConfiguration(v *types.AccountConfiguration, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.KmsKeyId != nil { + ok := object.Key("kmsKeyId") + ok.String(*v.KmsKeyId) + } + + return nil +} + func awsRestjson1_serializeDocumentAncillarySourceSettings(v *types.AncillarySourceSettings, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -6570,6 +6763,13 @@ func awsRestjson1_serializeDocumentEncoderSettings(v *types.EncoderSettings, val } } + if v.ThumbnailConfiguration != nil { + ok := object.Key("thumbnailConfiguration") + if err := awsRestjson1_serializeDocumentThumbnailConfiguration(v.ThumbnailConfiguration, ok); err != nil { + return err + } + } + if v.TimecodeConfig != nil { ok := object.Key("timecodeConfig") if err := awsRestjson1_serializeDocumentTimecodeConfig(v.TimecodeConfig, ok); err != nil { @@ -10555,6 +10755,18 @@ func awsRestjson1_serializeDocumentTemporalFilterSettings(v *types.TemporalFilte return nil } +func awsRestjson1_serializeDocumentThumbnailConfiguration(v *types.ThumbnailConfiguration, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if len(v.State) > 0 { + ok := object.Key("state") + ok.String(string(v.State)) + } + + return nil +} + func awsRestjson1_serializeDocumentTimecodeBurninSettings(v *types.TimecodeBurninSettings, value smithyjson.Value) error { object := value.Object() defer object.Close() diff --git a/service/medialive/types/enums.go b/service/medialive/types/enums.go index 5423b6b0502..42dd168e728 100644 --- a/service/medialive/types/enums.go +++ b/service/medialive/types/enums.go @@ -5079,6 +5079,42 @@ func (TemporalFilterStrength) Values() []TemporalFilterStrength { } } +type ThumbnailState string + +// Enum values for ThumbnailState +const ( + ThumbnailStateAuto ThumbnailState = "AUTO" + ThumbnailStateDisabled ThumbnailState = "DISABLED" +) + +// Values returns all known values for ThumbnailState. 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 (ThumbnailState) Values() []ThumbnailState { + return []ThumbnailState{ + "AUTO", + "DISABLED", + } +} + +type ThumbnailType string + +// Enum values for ThumbnailType +const ( + ThumbnailTypeUnspecified ThumbnailType = "UNSPECIFIED" + ThumbnailTypeCurrentActive ThumbnailType = "CURRENT_ACTIVE" +) + +// Values returns all known values for ThumbnailType. 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 (ThumbnailType) Values() []ThumbnailType { + return []ThumbnailType{ + "UNSPECIFIED", + "CURRENT_ACTIVE", + } +} + type TimecodeBurninFontSize string // Enum values for TimecodeBurninFontSize diff --git a/service/medialive/types/types.go b/service/medialive/types/types.go index ff46e4ad852..0fd97cdeae5 100644 --- a/service/medialive/types/types.go +++ b/service/medialive/types/types.go @@ -4,6 +4,7 @@ package types import ( smithydocument "github.com/aws/smithy-go/document" + "time" ) // Aac Settings @@ -83,6 +84,17 @@ type Ac3Settings struct { noSmithyDocumentSerde } +// Placeholder documentation for AccountConfiguration +type AccountConfiguration struct { + + // Specifies the KMS key to use for all features that use key encryption. Specify + // the ARN of a KMS key that you have created. Or leave blank to use the key that + // MediaLive creates and manages for you. + KmsKeyId *string + + noSmithyDocumentSerde +} + // Ancillary Source Settings type AncillarySourceSettings struct { @@ -1515,6 +1527,9 @@ type EncoderSettings struct { // Nielsen configuration settings. NielsenConfiguration *NielsenConfiguration + // Thumbnail configuration settings. + ThumbnailConfiguration *ThumbnailConfiguration + noSmithyDocumentSerde } @@ -5370,6 +5385,47 @@ type TemporalFilterSettings struct { noSmithyDocumentSerde } +// Details of a single thumbnail +type Thumbnail struct { + + // The binary data for the latest thumbnail. + Body *string + + // The content type for the latest thumbnail. + ContentType *string + + // Thumbnail Type + ThumbnailType ThumbnailType + + // Time stamp for the latest thumbnail. + TimeStamp *time.Time + + noSmithyDocumentSerde +} + +// Thumbnail Configuration +type ThumbnailConfiguration struct { + + // Whether Thumbnail is enabled. + // + // This member is required. + State ThumbnailState + + noSmithyDocumentSerde +} + +// Thumbnail details for one pipeline of a running channel. +type ThumbnailDetail struct { + + // Pipeline ID + PipelineId *string + + // thumbnails of a single pipeline + Thumbnails []Thumbnail + + noSmithyDocumentSerde +} + // Timecode Burnin Settings type TimecodeBurninSettings struct { diff --git a/service/medialive/validators.go b/service/medialive/validators.go index 225648740c5..9a38f664640 100644 --- a/service/medialive/validators.go +++ b/service/medialive/validators.go @@ -550,6 +550,26 @@ func (m *validateOpDescribeSchedule) HandleInitialize(ctx context.Context, in mi return next.HandleInitialize(ctx, in) } +type validateOpDescribeThumbnails struct { +} + +func (*validateOpDescribeThumbnails) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDescribeThumbnails) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DescribeThumbnailsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDescribeThumbnailsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpListInputDeviceTransfers struct { } @@ -1058,6 +1078,10 @@ func addOpDescribeScheduleValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpDescribeSchedule{}, middleware.After) } +func addOpDescribeThumbnailsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDescribeThumbnails{}, middleware.After) +} + func addOpListInputDeviceTransfersValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpListInputDeviceTransfers{}, middleware.After) } @@ -2056,6 +2080,11 @@ func validateEncoderSettings(v *types.EncoderSettings) error { invalidParams.AddNested("VideoDescriptions", err.(smithy.InvalidParamsError)) } } + if v.ThumbnailConfiguration != nil { + if err := validateThumbnailConfiguration(v.ThumbnailConfiguration); err != nil { + invalidParams.AddNested("ThumbnailConfiguration", err.(smithy.InvalidParamsError)) + } + } if invalidParams.Len() > 0 { return invalidParams } else { @@ -3187,6 +3216,21 @@ func validateTeletextSourceSettings(v *types.TeletextSourceSettings) error { } } +func validateThumbnailConfiguration(v *types.ThumbnailConfiguration) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ThumbnailConfiguration"} + if len(v.State) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("State")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateTimecodeBurninSettings(v *types.TimecodeBurninSettings) error { if v == nil { return nil @@ -3793,6 +3837,27 @@ func validateOpDescribeScheduleInput(v *DescribeScheduleInput) error { } } +func validateOpDescribeThumbnailsInput(v *DescribeThumbnailsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DescribeThumbnailsInput"} + if v.ChannelId == nil { + invalidParams.Add(smithy.NewErrParamRequired("ChannelId")) + } + if v.PipelineId == nil { + invalidParams.Add(smithy.NewErrParamRequired("PipelineId")) + } + if v.ThumbnailType == nil { + invalidParams.Add(smithy.NewErrParamRequired("ThumbnailType")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpListInputDeviceTransfersInput(v *ListInputDeviceTransfersInput) error { if v == nil { return nil diff --git a/service/mediatailor/deserializers.go b/service/mediatailor/deserializers.go index 17fc2e4fe77..9fe84d3e06f 100644 --- a/service/mediatailor/deserializers.go +++ b/service/mediatailor/deserializers.go @@ -7744,6 +7744,11 @@ func awsRestjson1_deserializeDocumentAdBreak(v **types.AdBreak, value interface{ for key, value := range shape { switch key { + case "AdBreakMetadata": + if err := awsRestjson1_deserializeDocumentAdBreakMetadataList(&sv.AdBreakMetadata, value); err != nil { + return err + } + case "MessageType": if value != nil { jtv, ok := value.(string) @@ -7790,6 +7795,40 @@ func awsRestjson1_deserializeDocumentAdBreak(v **types.AdBreak, value interface{ return nil } +func awsRestjson1_deserializeDocumentAdBreakMetadataList(v *[]types.KeyValuePair, 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.KeyValuePair + if *v == nil { + cv = []types.KeyValuePair{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.KeyValuePair + destAddr := &col + if err := awsRestjson1_deserializeDocumentKeyValuePair(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + func awsRestjson1_deserializeDocumentAdMarkerPassthrough(v **types.AdMarkerPassthrough, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -7830,6 +7869,42 @@ func awsRestjson1_deserializeDocumentAdMarkerPassthrough(v **types.AdMarkerPasst return nil } +func awsRestjson1_deserializeDocumentAdMarkupTypes(v *[]types.AdMarkupType, 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.AdMarkupType + if *v == nil { + cv = []types.AdMarkupType{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.AdMarkupType + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AdMarkupType to be of type string, got %T instead", value) + } + col = types.AdMarkupType(jtv) + } + cv = append(cv, col) + + } + *v = cv + return nil +} + func awsRestjson1_deserializeDocumentAlert(v **types.Alert, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -8603,6 +8678,11 @@ func awsRestjson1_deserializeDocumentHlsPlaylistSettings(v **types.HlsPlaylistSe for key, value := range shape { switch key { + case "AdMarkupType": + if err := awsRestjson1_deserializeDocumentAdMarkupTypes(&sv.AdMarkupType, value); err != nil { + return err + } + case "ManifestWindowSeconds": if value != nil { jtv, ok := value.(json.Number) @@ -8757,6 +8837,55 @@ func awsRestjson1_deserializeDocumentHttpPackageConfigurations(v *[]types.HttpPa return nil } +func awsRestjson1_deserializeDocumentKeyValuePair(v **types.KeyValuePair, 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.KeyValuePair + if *v == nil { + sv = &types.KeyValuePair{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "Key": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.Key = ptr.String(jtv) + } + + case "Value": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.Value = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsRestjson1_deserializeDocumentLivePreRollConfiguration(v **types.LivePreRollConfiguration, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) diff --git a/service/mediatailor/serializers.go b/service/mediatailor/serializers.go index 8b210d1e52f..37e9e1c25c6 100644 --- a/service/mediatailor/serializers.go +++ b/service/mediatailor/serializers.go @@ -3423,6 +3423,13 @@ func awsRestjson1_serializeDocumentAdBreak(v *types.AdBreak, value smithyjson.Va object := value.Object() defer object.Close() + if v.AdBreakMetadata != nil { + ok := object.Key("AdBreakMetadata") + if err := awsRestjson1_serializeDocumentAdBreakMetadataList(v.AdBreakMetadata, ok); err != nil { + return err + } + } + if len(v.MessageType) > 0 { ok := object.Key("MessageType") ok.String(string(v.MessageType)) @@ -3457,6 +3464,19 @@ func awsRestjson1_serializeDocumentAdBreak(v *types.AdBreak, value smithyjson.Va return nil } +func awsRestjson1_serializeDocumentAdBreakMetadataList(v []types.KeyValuePair, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + if err := awsRestjson1_serializeDocumentKeyValuePair(&v[i], av); err != nil { + return err + } + } + return nil +} + func awsRestjson1_serializeDocumentAdMarkerPassthrough(v *types.AdMarkerPassthrough, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -3469,6 +3489,17 @@ func awsRestjson1_serializeDocumentAdMarkerPassthrough(v *types.AdMarkerPassthro return nil } +func awsRestjson1_serializeDocumentAdMarkupTypes(v []types.AdMarkupType, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + av.String(string(v[i])) + } + return nil +} + func awsRestjson1_serializeDocumentAvailMatchingCriteria(v *types.AvailMatchingCriteria, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -3630,6 +3661,13 @@ func awsRestjson1_serializeDocumentHlsPlaylistSettings(v *types.HlsPlaylistSetti object := value.Object() defer object.Close() + if v.AdMarkupType != nil { + ok := object.Key("AdMarkupType") + if err := awsRestjson1_serializeDocumentAdMarkupTypes(v.AdMarkupType, ok); err != nil { + return err + } + } + if v.ManifestWindowSeconds != 0 { ok := object.Key("ManifestWindowSeconds") ok.Integer(v.ManifestWindowSeconds) @@ -3685,6 +3723,23 @@ func awsRestjson1_serializeDocumentHttpPackageConfigurations(v []types.HttpPacka return nil } +func awsRestjson1_serializeDocumentKeyValuePair(v *types.KeyValuePair, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Key != nil { + ok := object.Key("Key") + ok.String(*v.Key) + } + + if v.Value != nil { + ok := object.Key("Value") + ok.String(*v.Value) + } + + return nil +} + func awsRestjson1_serializeDocumentLivePreRollConfiguration(v *types.LivePreRollConfiguration, value smithyjson.Value) error { object := value.Object() defer object.Close() diff --git a/service/mediatailor/types/enums.go b/service/mediatailor/types/enums.go index 055aa27cc5b..0b50d426a53 100644 --- a/service/mediatailor/types/enums.go +++ b/service/mediatailor/types/enums.go @@ -20,6 +20,24 @@ func (AccessType) Values() []AccessType { } } +type AdMarkupType string + +// Enum values for AdMarkupType +const ( + AdMarkupTypeDaterange AdMarkupType = "DATERANGE" + AdMarkupTypeScte35Enhanced AdMarkupType = "SCTE35_ENHANCED" +) + +// Values returns all known values for AdMarkupType. 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 (AdMarkupType) Values() []AdMarkupType { + return []AdMarkupType{ + "DATERANGE", + "SCTE35_ENHANCED", + } +} + type ChannelState string // Enum values for ChannelState diff --git a/service/mediatailor/types/types.go b/service/mediatailor/types/types.go index c77bed49714..e3ce8f3995c 100644 --- a/service/mediatailor/types/types.go +++ b/service/mediatailor/types/types.go @@ -37,6 +37,10 @@ type AccessConfiguration struct { // Ad break configuration parameters. type AdBreak struct { + // Defines a list of key/value pairs that MediaTailor generates within the + // EXT-X-ASSET tag for SCTE35_ENHANCED output. + AdBreakMetadata []KeyValuePair + // The SCTE-35 ad insertion type. Accepted value: SPLICE_INSERT , TIME_SIGNAL . MessageType MessageType @@ -384,6 +388,11 @@ type HlsConfiguration struct { // HLS playlist configuration parameters. type HlsPlaylistSettings struct { + // Determines the type of SCTE 35 tags to use in ad markup. Specify DATERANGE to + // use DATERANGE tags (for live or VOD content). Specify SCTE35_ENHANCED to use + // EXT-X-CUE-OUT and EXT-X-CUE-IN tags (for VOD content only). + AdMarkupType []AdMarkupType + // The total duration (in seconds) of each manifest. Minimum value: 30 seconds. // Maximum value: 3600 seconds. ManifestWindowSeconds int32 @@ -427,6 +436,27 @@ type HttpPackageConfiguration struct { noSmithyDocumentSerde } +// For SCTE35_ENHANCED output, defines a key and corresponding value. MediaTailor +// generates these pairs within the EXT-X-ASSET tag. +type KeyValuePair struct { + + // For SCTE35_ENHANCED output, defines a key. MediaTailor takes this key, and its + // associated value, and generates the key/value pair within the EXT-X-ASSET tag. + // If you specify a key, you must also specify a corresponding value. + // + // This member is required. + Key *string + + // For SCTE35_ENHANCED output, defines a vaue. MediaTailor; takes this value, and + // its associated key, and generates the key/value pair within the EXT-X-ASSET tag. + // If you specify a value, you must also specify a corresponding key. + // + // This member is required. + Value *string + + noSmithyDocumentSerde +} + // The configuration for pre-roll ad insertion. type LivePreRollConfiguration struct { diff --git a/service/mediatailor/validators.go b/service/mediatailor/validators.go index d29f3a8bded..c2225de6356 100644 --- a/service/mediatailor/validators.go +++ b/service/mediatailor/validators.go @@ -994,6 +994,23 @@ func addOpUpdateVodSourceValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpUpdateVodSource{}, middleware.After) } +func validate__listOfAdBreak(v []types.AdBreak) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ListOfAdBreak"} + for i := range v { + if err := validateAdBreak(&v[i]); err != nil { + invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validate__listOfAvailMatchingCriteria(v []types.AvailMatchingCriteria) error { if v == nil { return nil @@ -1011,6 +1028,40 @@ func validate__listOfAvailMatchingCriteria(v []types.AvailMatchingCriteria) erro } } +func validateAdBreak(v *types.AdBreak) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "AdBreak"} + if v.AdBreakMetadata != nil { + if err := validateAdBreakMetadataList(v.AdBreakMetadata); err != nil { + invalidParams.AddNested("AdBreakMetadata", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateAdBreakMetadataList(v []types.KeyValuePair) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "AdBreakMetadataList"} + for i := range v { + if err := validateKeyValuePair(&v[i]); err != nil { + invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateAvailMatchingCriteria(v *types.AvailMatchingCriteria) error { if v == nil { return nil @@ -1094,6 +1145,24 @@ func validateHttpPackageConfigurations(v []types.HttpPackageConfiguration) error } } +func validateKeyValuePair(v *types.KeyValuePair) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "KeyValuePair"} + if v.Key == nil { + invalidParams.Add(smithy.NewErrParamRequired("Key")) + } + if v.Value == nil { + invalidParams.Add(smithy.NewErrParamRequired("Value")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validatePrefetchConsumption(v *types.PrefetchConsumption) error { if v == nil { return nil @@ -1343,6 +1412,11 @@ func validateOpCreateProgramInput(v *CreateProgramInput) error { return nil } invalidParams := smithy.InvalidParamsError{Context: "CreateProgramInput"} + if v.AdBreaks != nil { + if err := validate__listOfAdBreak(v.AdBreaks); err != nil { + invalidParams.AddNested("AdBreaks", err.(smithy.InvalidParamsError)) + } + } if v.ChannelName == nil { invalidParams.Add(smithy.NewErrParamRequired("ChannelName")) } @@ -1918,6 +1992,11 @@ func validateOpUpdateProgramInput(v *UpdateProgramInput) error { return nil } invalidParams := smithy.InvalidParamsError{Context: "UpdateProgramInput"} + if v.AdBreaks != nil { + if err := validate__listOfAdBreak(v.AdBreaks); err != nil { + invalidParams.AddNested("AdBreaks", err.(smithy.InvalidParamsError)) + } + } if v.ChannelName == nil { invalidParams.Add(smithy.NewErrParamRequired("ChannelName")) } diff --git a/service/networkfirewall/internal/endpoints/endpoints.go b/service/networkfirewall/internal/endpoints/endpoints.go index c5a9fb94104..4df28f2cc14 100644 --- a/service/networkfirewall/internal/endpoints/endpoints.go +++ b/service/networkfirewall/internal/endpoints/endpoints.go @@ -157,6 +157,9 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "ap-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-south-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "ap-southeast-1", }: endpoints.Endpoint{}, @@ -166,6 +169,9 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "ap-southeast-3", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-southeast-4", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "ca-central-1", }: endpoints.Endpoint{}, @@ -178,12 +184,18 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "eu-central-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-central-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-north-1", }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-south-2", + }: endpoints.Endpoint{}, endpoints.EndpointKey{ Region: "eu-west-1", }: endpoints.Endpoint{},