From 2ee27f3d7777e4860fc89f48cfb2d72654de28d4 Mon Sep 17 00:00:00 2001 From: AWS SDK for Go v2 automation user Date: Tue, 14 Mar 2023 18:18:25 +0000 Subject: [PATCH] Regenerated Clients --- .../2cb1b3804398469ebcfff8c028519a0f.json | 8 + .../31298cdb4154432e9fcdd060de189ea6.json | 8 + .../57cb1f1b8a0e41c0b2e0a6d12e3419f4.json | 8 + .../7eadd17d92374a9082a5b86156c1079c.json | 8 + .../8a9d57c1a7d046a8b3fa40e85600ba2d.json | 8 + .../a2b36a52c0ed49dfac123815a82f50d9.json | 8 + .../internal/endpoints/endpoints.go | 36 +++ .../applicationautoscaling/deserializers.go | 302 ++++++++++++++++++ service/applicationautoscaling/doc.go | 40 ++- service/applicationautoscaling/serializers.go | 132 ++++++++ service/applicationautoscaling/types/types.go | 152 +++++++-- service/applicationautoscaling/validators.go | 123 ++++++- service/dataexchange/deserializers.go | 84 +++++ service/dataexchange/serializers.go | 32 ++ service/dataexchange/types/types.go | 24 ++ service/dataexchange/validators.go | 37 +++ service/directconnect/api_op_CreateBGPPeer.go | 12 +- .../api_op_CreateTransitVirtualInterface.go | 3 +- .../api_op_StartBgpFailoverTest.go | 2 +- service/directconnect/types/types.go | 4 + service/ec2/deserializers.go | 16 + service/ec2/serializers.go | 5 + service/ec2/types/types.go | 9 + service/eks/internal/endpoints/endpoints.go | 3 + .../iam/api_op_CreateOpenIDConnectProvider.go | 31 +- service/iam/api_op_CreateRole.go | 5 +- service/iam/api_op_CreateVirtualMFADevice.go | 10 +- .../api_op_GetOrganizationsAccessReport.go | 2 +- .../iam/api_op_TagOpenIDConnectProvider.go | 17 +- service/iam/api_op_TagUser.go | 4 +- service/iam/types/types.go | 8 +- service/keyspaces/api_op_CreateTable.go | 91 ++++-- service/keyspaces/api_op_GetTable.go | 13 +- service/keyspaces/api_op_RestoreTable.go | 66 +++- service/keyspaces/api_op_UpdateTable.go | 71 +++- service/keyspaces/deserializers.go | 45 +++ service/keyspaces/doc.go | 9 +- service/keyspaces/serializers.go | 26 ++ service/keyspaces/types/enums.go | 16 + service/keyspaces/types/types.go | 90 ++++-- service/keyspaces/validators.go | 25 ++ 41 files changed, 1431 insertions(+), 162 deletions(-) create mode 100644 .changelog/2cb1b3804398469ebcfff8c028519a0f.json create mode 100644 .changelog/31298cdb4154432e9fcdd060de189ea6.json create mode 100644 .changelog/57cb1f1b8a0e41c0b2e0a6d12e3419f4.json create mode 100644 .changelog/7eadd17d92374a9082a5b86156c1079c.json create mode 100644 .changelog/8a9d57c1a7d046a8b3fa40e85600ba2d.json create mode 100644 .changelog/a2b36a52c0ed49dfac123815a82f50d9.json diff --git a/.changelog/2cb1b3804398469ebcfff8c028519a0f.json b/.changelog/2cb1b3804398469ebcfff8c028519a0f.json new file mode 100644 index 00000000000..1cb235e40ae --- /dev/null +++ b/.changelog/2cb1b3804398469ebcfff8c028519a0f.json @@ -0,0 +1,8 @@ +{ + "id": "2cb1b380-4398-469e-bcff-f8c028519a0f", + "type": "documentation", + "description": "Documentation only updates to correct customer-reported issues", + "modules": [ + "service/iam" + ] +} \ No newline at end of file diff --git a/.changelog/31298cdb4154432e9fcdd060de189ea6.json b/.changelog/31298cdb4154432e9fcdd060de189ea6.json new file mode 100644 index 00000000000..06272c82dd8 --- /dev/null +++ b/.changelog/31298cdb4154432e9fcdd060de189ea6.json @@ -0,0 +1,8 @@ +{ + "id": "31298cdb-4154-432e-9fcd-d060de189ea6", + "type": "documentation", + "description": "describe-direct-connect-gateway-associations includes a new status, updating, indicating that the association is currently in-process of updating.", + "modules": [ + "service/directconnect" + ] +} \ No newline at end of file diff --git a/.changelog/57cb1f1b8a0e41c0b2e0a6d12e3419f4.json b/.changelog/57cb1f1b8a0e41c0b2e0a6d12e3419f4.json new file mode 100644 index 00000000000..ca996eff6e0 --- /dev/null +++ b/.changelog/57cb1f1b8a0e41c0b2e0a6d12e3419f4.json @@ -0,0 +1,8 @@ +{ + "id": "57cb1f1b-8a0e-41c0-b2e0-a6d12e3419f4", + "type": "feature", + "description": "Application Auto Scaling customers can now use mathematical functions to customize the metric used with Target Tracking policies within the policy configuration itself, saving the cost and effort of publishing the customizations as a separate metric.", + "modules": [ + "service/applicationautoscaling" + ] +} \ No newline at end of file diff --git a/.changelog/7eadd17d92374a9082a5b86156c1079c.json b/.changelog/7eadd17d92374a9082a5b86156c1079c.json new file mode 100644 index 00000000000..62e2d2e3a4d --- /dev/null +++ b/.changelog/7eadd17d92374a9082a5b86156c1079c.json @@ -0,0 +1,8 @@ +{ + "id": "7eadd17d-9237-4a90-82a5-b86156c1079c", + "type": "feature", + "description": "This release enables data providers to license direct access to S3 objects encrypted with Customer Managed Keys (CMK) in AWS KMS through AWS Data Exchange. Subscribers can use these keys to decrypt, then use the encrypted S3 objects shared with them, without creating or managing copies.", + "modules": [ + "service/dataexchange" + ] +} \ No newline at end of file diff --git a/.changelog/8a9d57c1a7d046a8b3fa40e85600ba2d.json b/.changelog/8a9d57c1a7d046a8b3fa40e85600ba2d.json new file mode 100644 index 00000000000..736a574e770 --- /dev/null +++ b/.changelog/8a9d57c1a7d046a8b3fa40e85600ba2d.json @@ -0,0 +1,8 @@ +{ + "id": "8a9d57c1-a7d0-46a8-b3fa-40e85600ba2d", + "type": "feature", + "description": "Adding support for client-side timestamps", + "modules": [ + "service/keyspaces" + ] +} \ No newline at end of file diff --git a/.changelog/a2b36a52c0ed49dfac123815a82f50d9.json b/.changelog/a2b36a52c0ed49dfac123815a82f50d9.json new file mode 100644 index 00000000000..f517e887cdf --- /dev/null +++ b/.changelog/a2b36a52c0ed49dfac123815a82f50d9.json @@ -0,0 +1,8 @@ +{ + "id": "a2b36a52-c0ed-49df-ac12-3815a82f50d9", + "type": "feature", + "description": "This release adds a new DnsOptions key (PrivateDnsOnlyForInboundResolverEndpoint) to CreateVpcEndpoint and ModifyVpcEndpoint APIs.", + "modules": [ + "service/ec2" + ] +} \ No newline at end of file diff --git a/service/accessanalyzer/internal/endpoints/endpoints.go b/service/accessanalyzer/internal/endpoints/endpoints.go index 6b2a50d63d8..8f2b8e83cf6 100644 --- a/service/accessanalyzer/internal/endpoints/endpoints.go +++ b/service/accessanalyzer/internal/endpoints/endpoints.go @@ -421,6 +421,24 @@ var defaultPartitions = endpoints.Partitions{ Region: "us-gov-east-1", }, }, + endpoints.EndpointKey{ + Region: "us-gov-east-1", + Variant: endpoints.FIPSVariant, + }: { + Hostname: "access-analyzer.us-gov-east-1.amazonaws.com", + CredentialScope: endpoints.CredentialScope{ + Region: "us-gov-east-1", + }, + }, + endpoints.EndpointKey{ + Region: "us-gov-east-1-fips", + }: endpoints.Endpoint{ + Hostname: "access-analyzer.us-gov-east-1.amazonaws.com", + CredentialScope: endpoints.CredentialScope{ + Region: "us-gov-east-1", + }, + Deprecated: aws.TrueTernary, + }, endpoints.EndpointKey{ Region: "us-gov-west-1", }: endpoints.Endpoint{ @@ -429,6 +447,24 @@ var defaultPartitions = endpoints.Partitions{ Region: "us-gov-west-1", }, }, + endpoints.EndpointKey{ + Region: "us-gov-west-1", + Variant: endpoints.FIPSVariant, + }: { + Hostname: "access-analyzer.us-gov-west-1.amazonaws.com", + CredentialScope: endpoints.CredentialScope{ + Region: "us-gov-west-1", + }, + }, + endpoints.EndpointKey{ + Region: "us-gov-west-1-fips", + }: endpoints.Endpoint{ + Hostname: "access-analyzer.us-gov-west-1.amazonaws.com", + CredentialScope: endpoints.CredentialScope{ + Region: "us-gov-west-1", + }, + Deprecated: aws.TrueTernary, + }, }, }, } diff --git a/service/applicationautoscaling/deserializers.go b/service/applicationautoscaling/deserializers.go index 9a36099fc47..9059fe913c1 100644 --- a/service/applicationautoscaling/deserializers.go +++ b/service/applicationautoscaling/deserializers.go @@ -1636,6 +1636,11 @@ func awsAwsjson11_deserializeDocumentCustomizedMetricSpecification(v **types.Cus sv.MetricName = ptr.String(jtv) } + case "Metrics": + if err := awsAwsjson11_deserializeDocumentTargetTrackingMetricDataQueries(&sv.Metrics, value); err != nil { + return err + } + case "Namespace": if value != nil { jtv, ok := value.(string) @@ -3120,6 +3125,303 @@ func awsAwsjson11_deserializeDocumentSuspendedState(v **types.SuspendedState, va return nil } +func awsAwsjson11_deserializeDocumentTargetTrackingMetric(v **types.TargetTrackingMetric, 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.TargetTrackingMetric + if *v == nil { + sv = &types.TargetTrackingMetric{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "Dimensions": + if err := awsAwsjson11_deserializeDocumentTargetTrackingMetricDimensions(&sv.Dimensions, value); err != nil { + return err + } + + case "MetricName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected TargetTrackingMetricName to be of type string, got %T instead", value) + } + sv.MetricName = ptr.String(jtv) + } + + case "Namespace": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected TargetTrackingMetricNamespace to be of type string, got %T instead", value) + } + sv.Namespace = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentTargetTrackingMetricDataQueries(v *[]types.TargetTrackingMetricDataQuery, 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.TargetTrackingMetricDataQuery + if *v == nil { + cv = []types.TargetTrackingMetricDataQuery{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.TargetTrackingMetricDataQuery + destAddr := &col + if err := awsAwsjson11_deserializeDocumentTargetTrackingMetricDataQuery(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentTargetTrackingMetricDataQuery(v **types.TargetTrackingMetricDataQuery, 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.TargetTrackingMetricDataQuery + if *v == nil { + sv = &types.TargetTrackingMetricDataQuery{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "Expression": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Expression to be of type string, got %T instead", value) + } + sv.Expression = ptr.String(jtv) + } + + case "Id": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected Id to be of type string, got %T instead", value) + } + sv.Id = ptr.String(jtv) + } + + case "Label": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected XmlString to be of type string, got %T instead", value) + } + sv.Label = ptr.String(jtv) + } + + case "MetricStat": + if err := awsAwsjson11_deserializeDocumentTargetTrackingMetricStat(&sv.MetricStat, value); err != nil { + return err + } + + case "ReturnData": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected ReturnData to be of type *bool, got %T instead", value) + } + sv.ReturnData = ptr.Bool(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentTargetTrackingMetricDimension(v **types.TargetTrackingMetricDimension, 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.TargetTrackingMetricDimension + if *v == nil { + sv = &types.TargetTrackingMetricDimension{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "Name": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected TargetTrackingMetricDimensionName to be of type string, got %T instead", value) + } + sv.Name = ptr.String(jtv) + } + + case "Value": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected TargetTrackingMetricDimensionValue to be of type string, got %T instead", value) + } + sv.Value = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentTargetTrackingMetricDimensions(v *[]types.TargetTrackingMetricDimension, 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.TargetTrackingMetricDimension + if *v == nil { + cv = []types.TargetTrackingMetricDimension{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.TargetTrackingMetricDimension + destAddr := &col + if err := awsAwsjson11_deserializeDocumentTargetTrackingMetricDimension(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + +func awsAwsjson11_deserializeDocumentTargetTrackingMetricStat(v **types.TargetTrackingMetricStat, 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.TargetTrackingMetricStat + if *v == nil { + sv = &types.TargetTrackingMetricStat{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "Metric": + if err := awsAwsjson11_deserializeDocumentTargetTrackingMetric(&sv.Metric, value); err != nil { + return err + } + + case "Stat": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected XmlString to be of type string, got %T instead", value) + } + sv.Stat = ptr.String(jtv) + } + + case "Unit": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected TargetTrackingMetricUnit to be of type string, got %T instead", value) + } + sv.Unit = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeDocumentTargetTrackingScalingPolicyConfiguration(v **types.TargetTrackingScalingPolicyConfiguration, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) diff --git a/service/applicationautoscaling/doc.go b/service/applicationautoscaling/doc.go index 24a2f93de1d..e9aef28f892 100644 --- a/service/applicationautoscaling/doc.go +++ b/service/applicationautoscaling/doc.go @@ -42,30 +42,28 @@ // * Custom resources provided by // your own applications or services // -// API Summary The Application Auto Scaling -// service API includes three key sets of actions: -// -// * Register and manage scalable -// targets - Register Amazon Web Services or custom resources as scalable targets -// (a resource that Application Auto Scaling can scale), set minimum and maximum -// capacity limits, and retrieve information on existing scalable targets. -// -// * -// Configure and manage automatic scaling - Define scaling policies to dynamically -// scale your resources in response to CloudWatch alarms, schedule one-time or -// recurring scaling actions, and retrieve your recent scaling activity history. -// -// * -// Suspend and resume scaling - Temporarily suspend and later resume automatic -// scaling by calling the RegisterScalableTarget +// To learn more about Application Auto Scaling, +// see the Application Auto Scaling User Guide +// (https://docs.aws.amazon.com/autoscaling/application/userguide/what-is-application-auto-scaling.html). +// API Summary The Application Auto Scaling service API includes three key sets of +// actions: +// +// * Register and manage scalable targets - Register Amazon Web Services +// or custom resources as scalable targets (a resource that Application Auto +// Scaling can scale), set minimum and maximum capacity limits, and retrieve +// information on existing scalable targets. +// +// * Configure and manage automatic +// scaling - Define scaling policies to dynamically scale your resources in +// response to CloudWatch alarms, schedule one-time or recurring scaling actions, +// and retrieve your recent scaling activity history. +// +// * Suspend and resume scaling +// - Temporarily suspend and later resume automatic scaling by calling the +// RegisterScalableTarget // (https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html) // API action for any Application Auto Scaling scalable target. You can suspend and // resume (individually or in combination) scale-out activities that are triggered // by a scaling policy, scale-in activities that are triggered by a scaling policy, // and scheduled scaling. -// -// To learn more about Application Auto Scaling, including -// information about granting IAM users required permissions for Application Auto -// Scaling actions, see the Application Auto Scaling User Guide -// (https://docs.aws.amazon.com/autoscaling/application/userguide/what-is-application-auto-scaling.html). package applicationautoscaling diff --git a/service/applicationautoscaling/serializers.go b/service/applicationautoscaling/serializers.go index 64f760aadb6..06e02faaf7c 100644 --- a/service/applicationautoscaling/serializers.go +++ b/service/applicationautoscaling/serializers.go @@ -582,6 +582,13 @@ func awsAwsjson11_serializeDocumentCustomizedMetricSpecification(v *types.Custom ok.String(*v.MetricName) } + if v.Metrics != nil { + ok := object.Key("Metrics") + if err := awsAwsjson11_serializeDocumentTargetTrackingMetricDataQueries(v.Metrics, ok); err != nil { + return err + } + } + if v.Namespace != nil { ok := object.Key("Namespace") ok.String(*v.Namespace) @@ -792,6 +799,131 @@ func awsAwsjson11_serializeDocumentSuspendedState(v *types.SuspendedState, value return nil } +func awsAwsjson11_serializeDocumentTargetTrackingMetric(v *types.TargetTrackingMetric, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Dimensions != nil { + ok := object.Key("Dimensions") + if err := awsAwsjson11_serializeDocumentTargetTrackingMetricDimensions(v.Dimensions, ok); err != nil { + return err + } + } + + if v.MetricName != nil { + ok := object.Key("MetricName") + ok.String(*v.MetricName) + } + + if v.Namespace != nil { + ok := object.Key("Namespace") + ok.String(*v.Namespace) + } + + return nil +} + +func awsAwsjson11_serializeDocumentTargetTrackingMetricDataQueries(v []types.TargetTrackingMetricDataQuery, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + if err := awsAwsjson11_serializeDocumentTargetTrackingMetricDataQuery(&v[i], av); err != nil { + return err + } + } + return nil +} + +func awsAwsjson11_serializeDocumentTargetTrackingMetricDataQuery(v *types.TargetTrackingMetricDataQuery, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Expression != nil { + ok := object.Key("Expression") + ok.String(*v.Expression) + } + + if v.Id != nil { + ok := object.Key("Id") + ok.String(*v.Id) + } + + if v.Label != nil { + ok := object.Key("Label") + ok.String(*v.Label) + } + + if v.MetricStat != nil { + ok := object.Key("MetricStat") + if err := awsAwsjson11_serializeDocumentTargetTrackingMetricStat(v.MetricStat, ok); err != nil { + return err + } + } + + if v.ReturnData != nil { + ok := object.Key("ReturnData") + ok.Boolean(*v.ReturnData) + } + + return nil +} + +func awsAwsjson11_serializeDocumentTargetTrackingMetricDimension(v *types.TargetTrackingMetricDimension, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Name != nil { + ok := object.Key("Name") + ok.String(*v.Name) + } + + if v.Value != nil { + ok := object.Key("Value") + ok.String(*v.Value) + } + + return nil +} + +func awsAwsjson11_serializeDocumentTargetTrackingMetricDimensions(v []types.TargetTrackingMetricDimension, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + if err := awsAwsjson11_serializeDocumentTargetTrackingMetricDimension(&v[i], av); err != nil { + return err + } + } + return nil +} + +func awsAwsjson11_serializeDocumentTargetTrackingMetricStat(v *types.TargetTrackingMetricStat, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.Metric != nil { + ok := object.Key("Metric") + if err := awsAwsjson11_serializeDocumentTargetTrackingMetric(v.Metric, ok); err != nil { + return err + } + } + + if v.Stat != nil { + ok := object.Key("Stat") + ok.String(*v.Stat) + } + + if v.Unit != nil { + ok := object.Key("Unit") + ok.String(*v.Unit) + } + + return nil +} + func awsAwsjson11_serializeDocumentTargetTrackingScalingPolicyConfiguration(v *types.TargetTrackingScalingPolicyConfiguration, value smithyjson.Value) error { object := value.Object() defer object.Close() diff --git a/service/applicationautoscaling/types/types.go b/service/applicationautoscaling/types/types.go index 0215787e65e..71bcf70dca8 100644 --- a/service/applicationautoscaling/types/types.go +++ b/service/applicationautoscaling/types/types.go @@ -44,41 +44,33 @@ type Alarm struct { // value of the metric should decrease when capacity increases, and increase when // capacity decreases. // -// For an example of how creating new metrics can be useful, -// see Scaling based on Amazon SQS -// (https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-using-sqs-queue.html) -// in the Amazon EC2 Auto Scaling User Guide. This topic mentions Auto Scaling -// groups, but the same scenario for Amazon SQS can apply to the target tracking -// scaling policies that you create for a Spot Fleet by using the Application Auto -// Scaling API. For more information about the CloudWatch terminology below, see -// Amazon CloudWatch concepts +// For more information about the CloudWatch terminology +// below, see Amazon CloudWatch concepts // (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html) // in the Amazon CloudWatch User Guide. type CustomizedMetricSpecification struct { + // The dimensions of the metric. Conditional: If you published your metric with + // dimensions, you must specify the same dimensions in your scaling policy. + Dimensions []MetricDimension + // The name of the metric. To get the exact metric name, namespace, and dimensions, // inspect the Metric // (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_Metric.html) // object that is returned by a call to ListMetrics // (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_ListMetrics.html). - // - // This member is required. MetricName *string + // The metrics to include in the target tracking scaling policy, as a metric data + // query. This can include both raw metric and metric math expressions. + Metrics []TargetTrackingMetricDataQuery + // The namespace of the metric. - // - // This member is required. Namespace *string // The statistic of the metric. - // - // This member is required. Statistic MetricStatistic - // The dimensions of the metric. Conditional: If you published your metric with - // dimensions, you must specify the same dimensions in your scaling policy. - Dimensions []MetricDimension - // The unit of the metric. For a complete list of the units that CloudWatch // supports, see the MetricDatum // (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html) @@ -1193,6 +1185,130 @@ type SuspendedState struct { noSmithyDocumentSerde } +// Represents a specific metric. Metric is a property of the +// TargetTrackingMetricStat object. +type TargetTrackingMetric struct { + + // The dimensions for the metric. For the list of available dimensions, see the + // Amazon Web Services documentation available from the table in Amazon Web + // Services services that publish CloudWatch metrics + // (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-services-cloudwatch-metrics.html) + // in the Amazon CloudWatch User Guide. Conditional: If you published your metric + // with dimensions, you must specify the same dimensions in your scaling policy. + Dimensions []TargetTrackingMetricDimension + + // The name of the metric. + MetricName *string + + // The namespace of the metric. For more information, see the table in Amazon Web + // Services services that publish CloudWatch metrics + // (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-services-cloudwatch-metrics.html) + // in the Amazon CloudWatch User Guide. + Namespace *string + + noSmithyDocumentSerde +} + +// The metric data to return. Also defines whether this call is returning data for +// one metric only, or whether it is performing a math expression on the values of +// returned metric statistics to create a new time series. A time series is a +// series of data points, each of which is associated with a timestamp. For more +// information and examples, see Create a target tracking scaling policy for +// Application Auto Scaling using metric math +// (https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking-metric-math.html) +// in the Application Auto Scaling User Guide. +type TargetTrackingMetricDataQuery struct { + + // A short name that identifies the object's results in the response. This name + // must be unique among all MetricDataQuery objects specified for a single scaling + // policy. If you are performing math expressions on this set of data, this name + // represents that data and can serve as a variable in the mathematical expression. + // The valid characters are letters, numbers, and underscores. The first character + // must be a lowercase letter. + // + // This member is required. + Id *string + + // The math expression to perform on the returned data, if this object is + // performing a math expression. This expression can use the Id of the other + // metrics to refer to those metrics, and can also use the Id of other expressions + // to use the result of those expressions. Conditional: Within each + // TargetTrackingMetricDataQuery object, you must specify either Expression or + // MetricStat, but not both. + Expression *string + + // A human-readable label for this metric or expression. This is especially useful + // if this is a math expression, so that you know what the value represents. + Label *string + + // Information about the metric data to return. Conditional: Within each + // MetricDataQuery object, you must specify either Expression or MetricStat, but + // not both. + MetricStat *TargetTrackingMetricStat + + // Indicates whether to return the timestamps and raw data values of this metric. + // If you use any math expressions, specify true for this value for only the final + // math expression that the metric specification is based on. You must specify + // false for ReturnData for all the other metrics and expressions used in the + // metric specification. If you are only retrieving metrics and not performing any + // math expressions, do not specify anything for ReturnData. This sets it to its + // default (true). + ReturnData *bool + + noSmithyDocumentSerde +} + +// Describes the dimension of a metric. +type TargetTrackingMetricDimension struct { + + // The name of the dimension. + // + // This member is required. + Name *string + + // The value of the dimension. + // + // This member is required. + Value *string + + noSmithyDocumentSerde +} + +// This structure defines the CloudWatch metric to return, along with the +// statistic, period, and unit. For more information about the CloudWatch +// terminology below, see Amazon CloudWatch concepts +// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html) +// in the Amazon CloudWatch User Guide. +type TargetTrackingMetricStat struct { + + // The CloudWatch metric to return, including the metric name, namespace, and + // dimensions. To get the exact metric name, namespace, and dimensions, inspect the + // Metric + // (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_Metric.html) + // object that is returned by a call to ListMetrics + // (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_ListMetrics.html). + // + // This member is required. + Metric *TargetTrackingMetric + + // The statistic to return. It can include any CloudWatch statistic or extended + // statistic. For a list of valid values, see the table in Statistics + // (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#Statistic) + // in the Amazon CloudWatch User Guide. The most commonly used metrics for scaling + // is Average + // + // This member is required. + Stat *string + + // The unit to use for the returned data points. For a complete list of the units + // that CloudWatch supports, see the MetricDatum + // (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html) + // data type in the Amazon CloudWatch API Reference. + Unit *string + + noSmithyDocumentSerde +} + // Represents a target tracking scaling policy configuration to use with // Application Auto Scaling. type TargetTrackingScalingPolicyConfiguration struct { diff --git a/service/applicationautoscaling/validators.go b/service/applicationautoscaling/validators.go index 21082d0890d..900b148090f 100644 --- a/service/applicationautoscaling/validators.go +++ b/service/applicationautoscaling/validators.go @@ -255,19 +255,15 @@ func validateCustomizedMetricSpecification(v *types.CustomizedMetricSpecificatio return nil } invalidParams := smithy.InvalidParamsError{Context: "CustomizedMetricSpecification"} - if v.MetricName == nil { - invalidParams.Add(smithy.NewErrParamRequired("MetricName")) - } - if v.Namespace == nil { - invalidParams.Add(smithy.NewErrParamRequired("Namespace")) - } if v.Dimensions != nil { if err := validateMetricDimensions(v.Dimensions); err != nil { invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError)) } } - if len(v.Statistic) == 0 { - invalidParams.Add(smithy.NewErrParamRequired("Statistic")) + if v.Metrics != nil { + if err := validateTargetTrackingMetricDataQueries(v.Metrics); err != nil { + invalidParams.AddNested("Metrics", err.(smithy.InvalidParamsError)) + } } if invalidParams.Len() > 0 { return invalidParams @@ -375,6 +371,117 @@ func validateStepScalingPolicyConfiguration(v *types.StepScalingPolicyConfigurat } } +func validateTargetTrackingMetric(v *types.TargetTrackingMetric) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "TargetTrackingMetric"} + if v.Dimensions != nil { + if err := validateTargetTrackingMetricDimensions(v.Dimensions); err != nil { + invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateTargetTrackingMetricDataQueries(v []types.TargetTrackingMetricDataQuery) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "TargetTrackingMetricDataQueries"} + for i := range v { + if err := validateTargetTrackingMetricDataQuery(&v[i]); err != nil { + invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateTargetTrackingMetricDataQuery(v *types.TargetTrackingMetricDataQuery) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "TargetTrackingMetricDataQuery"} + if v.Id == nil { + invalidParams.Add(smithy.NewErrParamRequired("Id")) + } + if v.MetricStat != nil { + if err := validateTargetTrackingMetricStat(v.MetricStat); err != nil { + invalidParams.AddNested("MetricStat", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateTargetTrackingMetricDimension(v *types.TargetTrackingMetricDimension) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "TargetTrackingMetricDimension"} + if v.Name == nil { + invalidParams.Add(smithy.NewErrParamRequired("Name")) + } + if v.Value == nil { + invalidParams.Add(smithy.NewErrParamRequired("Value")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateTargetTrackingMetricDimensions(v []types.TargetTrackingMetricDimension) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "TargetTrackingMetricDimensions"} + for i := range v { + if err := validateTargetTrackingMetricDimension(&v[i]); err != nil { + invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateTargetTrackingMetricStat(v *types.TargetTrackingMetricStat) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "TargetTrackingMetricStat"} + if v.Metric == nil { + invalidParams.Add(smithy.NewErrParamRequired("Metric")) + } else if v.Metric != nil { + if err := validateTargetTrackingMetric(v.Metric); err != nil { + invalidParams.AddNested("Metric", err.(smithy.InvalidParamsError)) + } + } + if v.Stat == nil { + invalidParams.Add(smithy.NewErrParamRequired("Stat")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateTargetTrackingScalingPolicyConfiguration(v *types.TargetTrackingScalingPolicyConfiguration) error { if v == nil { return nil diff --git a/service/dataexchange/deserializers.go b/service/dataexchange/deserializers.go index 082c9d19ed1..b54f8d18bed 100644 --- a/service/dataexchange/deserializers.go +++ b/service/dataexchange/deserializers.go @@ -7559,6 +7559,46 @@ func awsRestjson1_deserializeDocumentJobError(v **types.JobError, value interfac return nil } +func awsRestjson1_deserializeDocumentKmsKeyToGrant(v **types.KmsKeyToGrant, 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.KmsKeyToGrant + if *v == nil { + sv = &types.KmsKeyToGrant{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "KmsKeyArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected KmsKeyArn to be of type string, got %T instead", value) + } + sv.KmsKeyArn = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsRestjson1_deserializeDocumentLakeFormationDataPermissionAsset(v **types.LakeFormationDataPermissionAsset, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -8104,6 +8144,40 @@ func awsRestjson1_deserializeDocumentListOfJobError(v *[]types.JobError, value i return nil } +func awsRestjson1_deserializeDocumentListOfKmsKeysToGrant(v *[]types.KmsKeyToGrant, 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.KmsKeyToGrant + if *v == nil { + cv = []types.KmsKeyToGrant{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.KmsKeyToGrant + destAddr := &col + if err := awsRestjson1_deserializeDocumentKmsKeyToGrant(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + func awsRestjson1_deserializeDocumentListOfLFPermissions(v *[]types.LFPermission, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -8919,6 +8993,11 @@ func awsRestjson1_deserializeDocumentS3DataAccessAsset(v **types.S3DataAccessAss return err } + case "KmsKeysToGrant": + if err := awsRestjson1_deserializeDocumentListOfKmsKeysToGrant(&sv.KmsKeysToGrant, value); err != nil { + return err + } + case "S3AccessPointAlias": if value != nil { jtv, ok := value.(string) @@ -8987,6 +9066,11 @@ func awsRestjson1_deserializeDocumentS3DataAccessAssetSourceEntry(v **types.S3Da return err } + case "KmsKeysToGrant": + if err := awsRestjson1_deserializeDocumentListOfKmsKeysToGrant(&sv.KmsKeysToGrant, value); err != nil { + return err + } + default: _, _ = key, value diff --git a/service/dataexchange/serializers.go b/service/dataexchange/serializers.go index db630f6b4ca..bd846468169 100644 --- a/service/dataexchange/serializers.go +++ b/service/dataexchange/serializers.go @@ -2537,6 +2537,18 @@ func awsRestjson1_serializeDocumentImportAssetsFromS3RequestDetails(v *types.Imp return nil } +func awsRestjson1_serializeDocumentKmsKeyToGrant(v *types.KmsKeyToGrant, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.KmsKeyArn != nil { + ok := object.Key("KmsKeyArn") + ok.String(*v.KmsKeyArn) + } + + return nil +} + func awsRestjson1_serializeDocumentLFTag(v *types.LFTag, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -2604,6 +2616,19 @@ func awsRestjson1_serializeDocumentListOfDatabaseLFTagPolicyPermissions(v []type return nil } +func awsRestjson1_serializeDocumentListOfKmsKeysToGrant(v []types.KmsKeyToGrant, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + if err := awsRestjson1_serializeDocumentKmsKeyToGrant(&v[i], av); err != nil { + return err + } + } + return nil +} + func awsRestjson1_serializeDocumentListOfLFTags(v []types.LFTag, value smithyjson.Value) error { array := value.Array() defer array.Close() @@ -2815,6 +2840,13 @@ func awsRestjson1_serializeDocumentS3DataAccessAssetSourceEntry(v *types.S3DataA } } + if v.KmsKeysToGrant != nil { + ok := object.Key("KmsKeysToGrant") + if err := awsRestjson1_serializeDocumentListOfKmsKeysToGrant(v.KmsKeysToGrant, ok); err != nil { + return err + } + } + return nil } diff --git a/service/dataexchange/types/types.go b/service/dataexchange/types/types.go index e9d6a55aca0..2a91c46ade8 100644 --- a/service/dataexchange/types/types.go +++ b/service/dataexchange/types/types.go @@ -954,6 +954,21 @@ type JobError struct { noSmithyDocumentSerde } +// The Amazon Resource Name (ARN) of the AWS KMS key used to encrypt the shared S3 +// objects. +type KmsKeyToGrant struct { + + // The AWS KMS CMK (Key Management System Customer Managed Key) used to encrypt S3 + // objects in the shared S3 Bucket. AWS Data exchange will create a KMS grant for + // each subscriber to allow them to access and decrypt their entitled data that is + // encrypted using this KMS key specified. + // + // This member is required. + KmsKeyArn *string + + noSmithyDocumentSerde +} + // The AWS Lake Formation data permission asset. type LakeFormationDataPermissionAsset struct { @@ -1244,6 +1259,11 @@ type S3DataAccessAsset struct { // S3 keys made available using this asset. Keys []string + // List of AWS KMS CMKs (Key Management System Customer Managed Keys) and ARNs used + // to encrypt S3 objects being shared in this S3 Data Access asset. Providers must + // include all AWS KMS keys used to encrypt these shared S3 objects. + KmsKeysToGrant []KmsKeyToGrant + // The automatically-generated bucket-style alias for your Amazon S3 Access Point. // Customers can access their entitled data using the S3 Access Point alias. S3AccessPointAlias *string @@ -1269,6 +1289,10 @@ type S3DataAccessAssetSourceEntry struct { // The keys used to create the Amazon S3 data access. Keys []string + // List of AWS KMS CMKs (Key Management System Customer Managed Keys) and ARNs used + // to encrypt S3 objects being shared in this S3 Data Access asset. + KmsKeysToGrant []KmsKeyToGrant + noSmithyDocumentSerde } diff --git a/service/dataexchange/validators.go b/service/dataexchange/validators.go index 90e409e6729..1158f211205 100644 --- a/service/dataexchange/validators.go +++ b/service/dataexchange/validators.go @@ -1024,6 +1024,21 @@ func validateImportAssetsFromS3RequestDetails(v *types.ImportAssetsFromS3Request } } +func validateKmsKeyToGrant(v *types.KmsKeyToGrant) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "KmsKeyToGrant"} + if v.KmsKeyArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("KmsKeyArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateLFTag(v *types.LFTag) error { if v == nil { return nil @@ -1076,6 +1091,23 @@ func validateListOfAssetSourceEntry(v []types.AssetSourceEntry) error { } } +func validateListOfKmsKeysToGrant(v []types.KmsKeyToGrant) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ListOfKmsKeysToGrant"} + for i := range v { + if err := validateKmsKeyToGrant(&v[i]); err != nil { + invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateListOfLFTags(v []types.LFTag) error { if v == nil { return nil @@ -1240,6 +1272,11 @@ func validateS3DataAccessAssetSourceEntry(v *types.S3DataAccessAssetSourceEntry) if v.Bucket == nil { invalidParams.Add(smithy.NewErrParamRequired("Bucket")) } + if v.KmsKeysToGrant != nil { + if err := validateListOfKmsKeysToGrant(v.KmsKeysToGrant); err != nil { + invalidParams.AddNested("KmsKeysToGrant", err.(smithy.InvalidParamsError)) + } + } if invalidParams.Len() > 0 { return invalidParams } else { diff --git a/service/directconnect/api_op_CreateBGPPeer.go b/service/directconnect/api_op_CreateBGPPeer.go index d8ada575d3f..52d09e0d993 100644 --- a/service/directconnect/api_op_CreateBGPPeer.go +++ b/service/directconnect/api_op_CreateBGPPeer.go @@ -18,9 +18,15 @@ import ( // in the same address family as an existing BGP peer on the virtual interface. // When creating a IPv6 BGP peer, omit the Amazon address and customer address. // IPv6 addresses are automatically assigned from the Amazon pool of IPv6 -// addresses; you cannot specify custom IPv6 addresses. For a public virtual -// interface, the Autonomous System Number (ASN) must be private or already on the -// allow list for the virtual interface. +// addresses; you cannot specify custom IPv6 addresses. If you let Amazon Web +// Services auto-assign IPv4 addresses, a /30 CIDR will be allocated from +// 169.254.0.0/16. Amazon Web Services does not recommend this option if you intend +// to use the customer router peer IP address as the source and destination for +// traffic. Instead you should use RFC 1918 or other addressing, and specify the +// address yourself. For more information about RFC 1918 see Address Allocation +// for Private Internets (https://datatracker.ietf.org/doc/html/rfc1918). For a +// public virtual interface, the Autonomous System Number (ASN) must be private or +// already on the allow list for the virtual interface. func (c *Client) CreateBGPPeer(ctx context.Context, params *CreateBGPPeerInput, optFns ...func(*Options)) (*CreateBGPPeerOutput, error) { if params == nil { params = &CreateBGPPeerInput{} diff --git a/service/directconnect/api_op_CreateTransitVirtualInterface.go b/service/directconnect/api_op_CreateTransitVirtualInterface.go index 00ee65c66b1..f856a9047ef 100644 --- a/service/directconnect/api_op_CreateTransitVirtualInterface.go +++ b/service/directconnect/api_op_CreateTransitVirtualInterface.go @@ -18,7 +18,8 @@ import ( // gateway with one or more Direct Connect gateways, the Autonomous System Number // (ASN) used by the transit gateway and the Direct Connect gateway must be // different. For example, if you use the default ASN 64512 for both your the -// transit gateway and Direct Connect gateway, the association request fails. +// transit gateway and Direct Connect gateway, the association request fails. A +// jumbo MTU value must be either 1500 or 8500. No other values will be accepted. // Setting the MTU of a virtual interface to 8500 (jumbo frames) can cause an // update to the underlying physical connection if it wasn't updated to support // jumbo frames. Updating the connection disrupts network connectivity for all diff --git a/service/directconnect/api_op_StartBgpFailoverTest.go b/service/directconnect/api_op_StartBgpFailoverTest.go index 46c44f029eb..9fa18e03404 100644 --- a/service/directconnect/api_op_StartBgpFailoverTest.go +++ b/service/directconnect/api_op_StartBgpFailoverTest.go @@ -46,7 +46,7 @@ type StartBgpFailoverTestInput struct { BgpPeers []string // The time in minutes that the virtual interface failover test will last. Maximum - // value: 180 minutes (3 hours). Default: 180 minutes (3 hours). + // value: 4,320 minutes (72 hours). Default: 180 minutes (3 hours). TestDurationInMinutes *int32 noSmithyDocumentSerde diff --git a/service/directconnect/types/types.go b/service/directconnect/types/types.go index 2bcc41fd213..8eaffd20bcb 100644 --- a/service/directconnect/types/types.go +++ b/service/directconnect/types/types.go @@ -278,6 +278,10 @@ type DirectConnectGatewayAssociation struct { // gateway or transit gateway is disassociated from the Direct Connect gateway. // Traffic flow between the Direct Connect gateway and virtual private gateway or // transit gateway is stopped. + // + // * updating: The CIDR blocks for the virtual private + // gateway or transit gateway are currently being updated. This could be new CIDR + // blocks added or current CIDR blocks removed. AssociationState DirectConnectGatewayAssociationState // The ID of the Direct Connect gateway. diff --git a/service/ec2/deserializers.go b/service/ec2/deserializers.go index 6f9f4217b1d..cb20d6ffc55 100644 --- a/service/ec2/deserializers.go +++ b/service/ec2/deserializers.go @@ -66848,6 +66848,22 @@ func awsEc2query_deserializeDocumentDnsOptions(v **types.DnsOptions, decoder smi sv.DnsRecordIpType = types.DnsRecordIpType(xtv) } + case strings.EqualFold("privateDnsOnlyForInboundResolverEndpoint", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv, err := strconv.ParseBool(string(val)) + if err != nil { + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) + } + sv.PrivateDnsOnlyForInboundResolverEndpoint = ptr.Bool(xtv) + } + default: // Do nothing and ignore the unexpected tag element err = decoder.Decoder.Skip() diff --git a/service/ec2/serializers.go b/service/ec2/serializers.go index 97be6204cdf..30bd37161fd 100644 --- a/service/ec2/serializers.go +++ b/service/ec2/serializers.go @@ -39006,6 +39006,11 @@ func awsEc2query_serializeDocumentDnsOptionsSpecification(v *types.DnsOptionsSpe objectKey.String(string(v.DnsRecordIpType)) } + if v.PrivateDnsOnlyForInboundResolverEndpoint != nil { + objectKey := object.Key("PrivateDnsOnlyForInboundResolverEndpoint") + objectKey.Boolean(*v.PrivateDnsOnlyForInboundResolverEndpoint) + } + return nil } diff --git a/service/ec2/types/types.go b/service/ec2/types/types.go index e86478eab6a..29644235f45 100644 --- a/service/ec2/types/types.go +++ b/service/ec2/types/types.go @@ -2899,6 +2899,9 @@ type DnsOptions struct { // The DNS records created for the endpoint. DnsRecordIpType DnsRecordIpType + // Indicates whether to enable private DNS only for inbound endpoints. + PrivateDnsOnlyForInboundResolverEndpoint *bool + noSmithyDocumentSerde } @@ -2908,6 +2911,12 @@ type DnsOptionsSpecification struct { // The DNS records created for the endpoint. DnsRecordIpType DnsRecordIpType + // Indicates whether to enable private DNS only for inbound endpoints. This option + // is available only for services that support both gateway and interface + // endpoints. It routes traffic that originates from the VPC to the gateway + // endpoint and traffic that originates from on-premises to the interface endpoint. + PrivateDnsOnlyForInboundResolverEndpoint *bool + noSmithyDocumentSerde } diff --git a/service/eks/internal/endpoints/endpoints.go b/service/eks/internal/endpoints/endpoints.go index db00092c37d..086e7cdf56e 100644 --- a/service/eks/internal/endpoints/endpoints.go +++ b/service/eks/internal/endpoints/endpoints.go @@ -165,6 +165,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{}, diff --git a/service/iam/api_op_CreateOpenIDConnectProvider.go b/service/iam/api_op_CreateOpenIDConnectProvider.go index ba109179bf0..3ca16afc640 100644 --- a/service/iam/api_op_CreateOpenIDConnectProvider.go +++ b/service/iam/api_op_CreateOpenIDConnectProvider.go @@ -31,20 +31,23 @@ import ( // client IDs (also known as audiences) that identify the application or // applications allowed to authenticate using the OIDC provider // -// * A list of -// thumbprints of one or more server certificates that the IdP uses +// * A list of tags +// that are attached to the specified IAM OIDC provider +// +// * A list of thumbprints of +// one or more server certificates that the IdP uses // -// You get all of -// this information from the OIDC IdP you want to use to access Amazon Web -// Services. Amazon Web Services secures communication with some OIDC identity -// providers (IdPs) through our library of trusted certificate authorities (CAs) -// instead of using a certificate thumbprint to verify your IdP server certificate. -// These OIDC IdPs include Google, Auth0, and those that use an Amazon S3 bucket to -// host a JSON Web Key Set (JWKS) endpoint. In these cases, your legacy thumbprint -// remains in your configuration, but is no longer used for validation. The trust -// for the OIDC provider is derived from the IAM provider that this operation -// creates. Therefore, it is best to limit access to the -// CreateOpenIDConnectProvider operation to highly privileged users. +// You get all of this +// information from the OIDC IdP you want to use to access Amazon Web Services. +// Amazon Web Services secures communication with some OIDC identity providers +// (IdPs) through our library of trusted certificate authorities (CAs) instead of +// using a certificate thumbprint to verify your IdP server certificate. These OIDC +// IdPs include Google, Auth0, and those that use an Amazon S3 bucket to host a +// JSON Web Key Set (JWKS) endpoint. In these cases, your legacy thumbprint remains +// in your configuration, but is no longer used for validation. The trust for the +// OIDC provider is derived from the IAM provider that this operation creates. +// Therefore, it is best to limit access to the CreateOpenIDConnectProvider +// operation to highly privileged users. func (c *Client) CreateOpenIDConnectProvider(ctx context.Context, params *CreateOpenIDConnectProviderInput, optFns ...func(*Options)) (*CreateOpenIDConnectProviderOutput, error) { if params == nil { params = &CreateOpenIDConnectProviderInput{} @@ -77,7 +80,7 @@ type CreateOpenIDConnectProviderInput struct { // the OIDC provider thumbprint, see Obtaining the thumbprint for an OpenID Connect // provider // (https://docs.aws.amazon.com/IAM/latest/UserGuide/identity-providers-oidc-obtain-thumbprint.html) - // in the IAM User Guide. + // in the IAM user Guide. // // This member is required. ThumbprintList []string diff --git a/service/iam/api_op_CreateRole.go b/service/iam/api_op_CreateRole.go index e4e22ba4577..ecaedee0ce7 100644 --- a/service/iam/api_op_CreateRole.go +++ b/service/iam/api_op_CreateRole.go @@ -61,7 +61,10 @@ type CreateRoleInput struct { // The name of the role to create. IAM user, group, role, and policy names must be // unique within the account. Names are not distinguished by case. For example, you - // cannot create resources named both "MyResource" and "myresource". + // cannot create resources named both "MyResource" and "myresource". This parameter + // allows (through its regex pattern (http://wikipedia.org/wiki/regex)) a string of + // characters consisting of upper and lowercase alphanumeric characters with no + // spaces. You can also include any of the following characters: _+=,.@- // // This member is required. RoleName *string diff --git a/service/iam/api_op_CreateVirtualMFADevice.go b/service/iam/api_op_CreateVirtualMFADevice.go index 8fc2e0dc3a3..688940e9150 100644 --- a/service/iam/api_op_CreateVirtualMFADevice.go +++ b/service/iam/api_op_CreateVirtualMFADevice.go @@ -41,11 +41,11 @@ func (c *Client) CreateVirtualMFADevice(ctx context.Context, params *CreateVirtu type CreateVirtualMFADeviceInput struct { - // The name of the virtual MFA device. Use with path to uniquely identify a virtual - // MFA device. This parameter allows (through its regex pattern - // (http://wikipedia.org/wiki/regex)) a string of characters consisting of upper - // and lowercase alphanumeric characters with no spaces. You can also include any - // of the following characters: _+=,.@- + // The name of the virtual MFA device, which must be unique. Use with path to + // uniquely identify a virtual MFA device. This parameter allows (through its regex + // pattern (http://wikipedia.org/wiki/regex)) a string of characters consisting of + // upper and lowercase alphanumeric characters with no spaces. You can also include + // any of the following characters: _+=,.@- // // This member is required. VirtualMFADeviceName *string diff --git a/service/iam/api_op_GetOrganizationsAccessReport.go b/service/iam/api_op_GetOrganizationsAccessReport.go index c47ff2c9cfb..3a200ca3a5a 100644 --- a/service/iam/api_op_GetOrganizationsAccessReport.go +++ b/service/iam/api_op_GetOrganizationsAccessReport.go @@ -23,7 +23,7 @@ import ( // information, see Refining permissions using service last accessed data // (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html) // in the IAM User Guide. For each service that principals in an account (root -// users, IAM users, or IAM roles) could access using SCPs, the operation returns +// user, IAM users, or IAM roles) could access using SCPs, the operation returns // details about the most recent access attempt. If there was no attempt, the // service is listed without details about the most recent attempt to access the // service. If the operation fails, it returns the reason that it failed. By diff --git a/service/iam/api_op_TagOpenIDConnectProvider.go b/service/iam/api_op_TagOpenIDConnectProvider.go index 89d0e09489d..29332d37d4c 100644 --- a/service/iam/api_op_TagOpenIDConnectProvider.go +++ b/service/iam/api_op_TagOpenIDConnectProvider.go @@ -25,15 +25,16 @@ import ( // key name Cost Center and the value 41200. // // * Access control - Include tags in -// IAM user-based and resource-based policies. You can use tags to restrict access -// to only an OIDC provider that has a specified tag attached. For examples of -// policies that show how to use tags to control access, see Control access using -// IAM tags (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) in -// the IAM User Guide. +// IAM identity-based and resource-based policies. You can use tags to restrict +// access to only an OIDC provider that has a specified tag attached. For examples +// of policies that show how to use tags to control access, see Control access +// using IAM tags +// (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) in the IAM +// User Guide. // -// * If any one of the tags is invalid or if you exceed the -// allowed maximum number of tags, then the entire request fails and the resource -// is not created. For more information about tagging, see Tagging IAM resources +// * If any one of the tags is invalid or if you exceed the allowed +// maximum number of tags, then the entire request fails and the resource is not +// created. For more information about tagging, see Tagging IAM resources // (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html) in the IAM User // Guide. // diff --git a/service/iam/api_op_TagUser.go b/service/iam/api_op_TagUser.go index f18150b703c..6eca711066d 100644 --- a/service/iam/api_op_TagUser.go +++ b/service/iam/api_op_TagUser.go @@ -22,8 +22,8 @@ import ( // search for all resources with the key name Cost Center and the value 41200. // // * -// Access control - Include tags in IAM user-based and resource-based policies. You -// can use tags to restrict access to only an IAM requesting user that has a +// Access control - Include tags in IAM identity-based and resource-based policies. +// You can use tags to restrict access to only an IAM requesting user that has a // specified tag attached. You can also restrict access to only those resources // that have a certain tag attached. For examples of policies that show how to use // tags to control access, see Control access using IAM tags diff --git a/service/iam/types/types.go b/service/iam/types/types.go index a6e3e431473..b22b4e2879e 100644 --- a/service/iam/types/types.go +++ b/service/iam/types/types.go @@ -36,7 +36,7 @@ type AccessDetail struct { // The path of the Organizations entity (root, organizational unit, or account) // from which an authenticated principal last attempted to access the service. // Amazon Web Services does not report unauthenticated requests. This field is null - // if no principals (IAM users, IAM roles, or root users) in the reported + // if no principals (IAM users, IAM roles, or root user) in the reported // Organizations entity attempted to access the service within the tracking period // (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#service-last-accessed-reporting-period). EntityPath *string @@ -55,7 +55,7 @@ type AccessDetail struct { // (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#service-last-accessed-reporting-period). Region *string - // The number of accounts with authenticated principals (root users, IAM users, and + // The number of accounts with authenticated principals (root user, IAM users, and // IAM roles) that attempted to access the service in the tracking period. TotalAuthenticatedEntities *int32 @@ -1125,7 +1125,7 @@ type Role struct { // might have been used more than 400 days ago. For more information, see Regions // where data is tracked // (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#access-advisor_tracking-period) - // in the IAM User Guide. + // in the IAM user Guide. RoleLastUsed *RoleLastUsed // A list of tags that are attached to the role. For more information about @@ -1214,7 +1214,7 @@ type RoleDetail struct { // might have been used more than 400 days ago. For more information, see Regions // where data is tracked // (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#access-advisor_tracking-period) -// in the IAM User Guide. This data type is returned as a response element in the +// in the IAM user Guide. This data type is returned as a response element in the // GetRole and GetAccountAuthorizationDetails operations. type RoleLastUsed struct { diff --git a/service/keyspaces/api_op_CreateTable.go b/service/keyspaces/api_op_CreateTable.go index 4f32b6efb54..229425fd981 100644 --- a/service/keyspaces/api_op_CreateTable.go +++ b/service/keyspaces/api_op_CreateTable.go @@ -42,20 +42,41 @@ type CreateTableInput struct { KeyspaceName *string // The schemaDefinition consists of the following parameters. For each column to be - // created: • name - The name of the column. • type - An Amazon Keyspaces data + // created: + // + // * name - The name of the column. + // + // * type - An Amazon Keyspaces data // type. For more information, see Data types // (https://docs.aws.amazon.com/keyspaces/latest/devguide/cql.elements.html#cql.data-types) - // in the Amazon Keyspaces Developer Guide. The primary key of the table consists - // of the following columns: • partitionKeys - The partition key can be a single + // in the Amazon Keyspaces Developer Guide. + // + // The primary key of the table consists + // of the following columns: + // + // * partitionKeys - The partition key can be a single // column, or it can be a compound value composed of two or more columns. The // partition key portion of the primary key is required and determines how Amazon - // Keyspaces stores your data. • name - The name of each partition key column. • + // Keyspaces stores your data. + // + // * name - The name of each partition key column. + // + // * // clusteringKeys - The optional clustering column portion of your primary key - // determines how the data is clustered and sorted within each partition. • name - - // The name of the clustering column. • orderBy - Sets the ascendant (ASC) or + // determines how the data is clustered and sorted within each partition. + // + // * name - + // The name of the clustering column. + // + // * orderBy - Sets the ascendant (ASC) or // descendant (DESC) order modifier. To define a column as static use staticColumns - // - Static columns store values that are shared by all rows in the same partition: - // • name - The name of the column. • type - An Amazon Keyspaces data type. + // - Static columns store values that are shared by all rows in the same + // partition: + // + // * name - The name of the column. + // + // * type - An Amazon Keyspaces data + // type. // // This member is required. SchemaDefinition *types.SchemaDefinition @@ -66,14 +87,30 @@ type CreateTableInput struct { TableName *string // Specifies the read/write throughput capacity mode for the table. The options - // are: • throughputMode:PAY_PER_REQUEST and • throughputMode:PROVISIONED - + // are: + // + // * throughputMode:PAY_PER_REQUEST and + // + // * throughputMode:PROVISIONED - // Provisioned capacity mode requires readCapacityUnits and writeCapacityUnits as - // input. The default is throughput_mode:PAY_PER_REQUEST. For more information, see - // Read/write capacity modes + // input. + // + // The default is throughput_mode:PAY_PER_REQUEST. For more information, + // see Read/write capacity modes // (https://docs.aws.amazon.com/keyspaces/latest/devguide/ReadWriteCapacityMode.html) // in the Amazon Keyspaces Developer Guide. CapacitySpecification *types.CapacitySpecification + // Enables client-side timestamps for the table. By default, the setting is + // disabled. You can enable client-side timestamps with the following option: + // + // * + // status: "enabled" + // + // Once client-side timestamps are enabled for a table, this + // setting cannot be disabled. + ClientSideTimestamps *types.ClientSideTimestamps + // This parameter allows to enter a description of the table. Comment *types.Comment @@ -84,19 +121,31 @@ type CreateTableInput struct { DefaultTimeToLive *int32 // Specifies how the encryption key for encryption at rest is managed for the - // table. You can choose one of the following KMS key (KMS key): • - // type:AWS_OWNED_KMS_KEY - This key is owned by Amazon Keyspaces. • + // table. You can choose one of the following KMS key (KMS key): + // + // * + // type:AWS_OWNED_KMS_KEY - This key is owned by Amazon Keyspaces. + // + // * // type:CUSTOMER_MANAGED_KMS_KEY - This key is stored in your account and is // created, owned, and managed by you. This option requires the kms_key_identifier - // of the KMS key in Amazon Resource Name (ARN) format as input. The default is + // of the KMS key in Amazon Resource Name (ARN) format as input. + // + // The default is // type:AWS_OWNED_KMS_KEY. For more information, see Encryption at rest // (https://docs.aws.amazon.com/keyspaces/latest/devguide/EncryptionAtRest.html) in // the Amazon Keyspaces Developer Guide. EncryptionSpecification *types.EncryptionSpecification // Specifies if pointInTimeRecovery is enabled or disabled for the table. The - // options are: • ENABLED • DISABLED If it's not specified, the default is - // DISABLED. For more information, see Point-in-time recovery + // options are: + // + // * status=ENABLED + // + // * status=DISABLED + // + // If it's not specified, the + // default is status=DISABLED. For more information, see Point-in-time recovery // (https://docs.aws.amazon.com/keyspaces/latest/devguide/PointInTimeRecovery.html) // in the Amazon Keyspaces Developer Guide. PointInTimeRecovery *types.PointInTimeRecovery @@ -107,8 +156,14 @@ type CreateTableInput struct { // in the Amazon Keyspaces Developer Guide. Tags []types.Tag - // Enables Time to Live custom settings for the table. The options are: • - // status:enabled • status:disabled The default is status:disabled. After ttl is + // Enables Time to Live custom settings for the table. The options are: + // + // * + // status:enabled + // + // * status:disabled + // + // The default is status:disabled. After ttl is // enabled, you can't disable it for the table. For more information, see Expiring // data by using Amazon Keyspaces Time to Live (TTL) // (https://docs.aws.amazon.com/keyspaces/latest/devguide/TTL.html) in the Amazon diff --git a/service/keyspaces/api_op_GetTable.go b/service/keyspaces/api_op_GetTable.go index 8bee6ef35d5..873f0e501ad 100644 --- a/service/keyspaces/api_op_GetTable.go +++ b/service/keyspaces/api_op_GetTable.go @@ -63,17 +63,24 @@ type GetTableOutput struct { // This member is required. TableName *string - // The read/write throughput capacity mode for a table. The options are: • - // throughputMode:PAY_PER_REQUEST • throughputMode:PROVISIONED + // The read/write throughput capacity mode for a table. The options are: + // + // * + // throughputMode:PAY_PER_REQUEST + // + // * throughputMode:PROVISIONED CapacitySpecification *types.CapacitySpecificationSummary + // The client-side timestamps setting of the table. + ClientSideTimestamps *types.ClientSideTimestamps + // The the description of the specified table. Comment *types.Comment // The creation timestamp of the specified table. CreationTimestamp *time.Time - // The default Time to Live settings of the specified table. + // The default Time to Live settings in seconds of the specified table. DefaultTimeToLive *int32 // The encryption settings of the specified table. diff --git a/service/keyspaces/api_op_RestoreTable.go b/service/keyspaces/api_op_RestoreTable.go index ba53b666088..84010ad3d9e 100644 --- a/service/keyspaces/api_op_RestoreTable.go +++ b/service/keyspaces/api_op_RestoreTable.go @@ -27,14 +27,30 @@ import ( // the table's schema data and TTL settings, which are restored based on the // selected timestamp, these settings are always restored based on the table's // settings as of the current time or when the table was deleted. You can also -// overwrite these settings during restore: • Read/write capacity mode • -// Provisioned throughput capacity settings • Point-in-time (PITR) settings • Tags +// overwrite these settings during restore: +// +// * Read/write capacity mode +// +// * +// Provisioned throughput capacity settings +// +// * Point-in-time (PITR) settings +// +// * +// Tags +// // For more information, see PITR restore settings // (https://docs.aws.amazon.com/keyspaces/latest/devguide/PointInTimeRecovery_HowItWorks.html#howitworks_backup_settings) // in the Amazon Keyspaces Developer Guide. Note that the following settings are -// not restored, and you must configure them manually for the new table: • -// Automatic scaling policies (for tables that use provisioned capacity mode) • -// Identity and Access Management (IAM) policies • Amazon CloudWatch metrics and +// not restored, and you must configure them manually for the new table: +// +// * +// Automatic scaling policies (for tables that use provisioned capacity mode) +// +// * +// Identity and Access Management (IAM) policies +// +// * Amazon CloudWatch metrics and // alarms func (c *Client) RestoreTable(ctx context.Context, params *RestoreTableInput, optFns ...func(*Options)) (*RestoreTableOutput, error) { if params == nil { @@ -74,28 +90,46 @@ type RestoreTableInput struct { TargetTableName *string // Specifies the read/write throughput capacity mode for the target table. The - // options are: • throughputMode:PAY_PER_REQUEST • throughputMode:PROVISIONED - + // options are: + // + // * throughputMode:PAY_PER_REQUEST + // + // * throughputMode:PROVISIONED - // Provisioned capacity mode requires readCapacityUnits and writeCapacityUnits as - // input. The default is throughput_mode:PAY_PER_REQUEST. For more information, see - // Read/write capacity modes + // input. + // + // The default is throughput_mode:PAY_PER_REQUEST. For more information, + // see Read/write capacity modes // (https://docs.aws.amazon.com/keyspaces/latest/devguide/ReadWriteCapacityMode.html) // in the Amazon Keyspaces Developer Guide. CapacitySpecificationOverride *types.CapacitySpecification // Specifies the encryption settings for the target table. You can choose one of - // the following KMS key (KMS key): • type:AWS_OWNED_KMS_KEY - This key is owned by - // Amazon Keyspaces. • type:CUSTOMER_MANAGED_KMS_KEY - This key is stored in your - // account and is created, owned, and managed by you. This option requires the - // kms_key_identifier of the KMS key in Amazon Resource Name (ARN) format as input. - // The default is type:AWS_OWNED_KMS_KEY. For more information, see Encryption at - // rest + // the following KMS key (KMS key): + // + // * type:AWS_OWNED_KMS_KEY - This key is owned + // by Amazon Keyspaces. + // + // * type:CUSTOMER_MANAGED_KMS_KEY - This key is stored in + // your account and is created, owned, and managed by you. This option requires the + // kms_key_identifier of the KMS key in Amazon Resource Name (ARN) format as + // input. + // + // The default is type:AWS_OWNED_KMS_KEY. For more information, see + // Encryption at rest // (https://docs.aws.amazon.com/keyspaces/latest/devguide/EncryptionAtRest.html) in // the Amazon Keyspaces Developer Guide. EncryptionSpecificationOverride *types.EncryptionSpecification // Specifies the pointInTimeRecovery settings for the target table. The options - // are: • ENABLED • DISABLED If it's not specified, the default is DISABLED. For - // more information, see Point-in-time recovery + // are: + // + // * status=ENABLED + // + // * status=DISABLED + // + // If it's not specified, the default is + // status=DISABLED. For more information, see Point-in-time recovery // (https://docs.aws.amazon.com/keyspaces/latest/devguide/PointInTimeRecovery.html) // in the Amazon Keyspaces Developer Guide. PointInTimeRecoveryOverride *types.PointInTimeRecovery diff --git a/service/keyspaces/api_op_UpdateTable.go b/service/keyspaces/api_op_UpdateTable.go index 247833eaae8..fc8c3df7c1f 100644 --- a/service/keyspaces/api_op_UpdateTable.go +++ b/service/keyspaces/api_op_UpdateTable.go @@ -41,22 +41,42 @@ type UpdateTableInput struct { // This member is required. TableName *string - // For each column to be added to the specified table: • name - The name of the - // column. • type - An Amazon Keyspaces data type. For more information, see Data + // For each column to be added to the specified table: + // + // * name - The name of the + // column. + // + // * type - An Amazon Keyspaces data type. For more information, see Data // types // (https://docs.aws.amazon.com/keyspaces/latest/devguide/cql.elements.html#cql.data-types) // in the Amazon Keyspaces Developer Guide. AddColumns []types.ColumnDefinition - // Modifies the read/write throughput capacity mode for the table. The options are: - // • throughputMode:PAY_PER_REQUEST and • throughputMode:PROVISIONED - Provisioned - // capacity mode requires readCapacityUnits and writeCapacityUnits as input. The - // default is throughput_mode:PAY_PER_REQUEST. For more information, see Read/write - // capacity modes + // Modifies the read/write throughput capacity mode for the table. The options + // are: + // + // * throughputMode:PAY_PER_REQUEST and + // + // * throughputMode:PROVISIONED - + // Provisioned capacity mode requires readCapacityUnits and writeCapacityUnits as + // input. + // + // The default is throughput_mode:PAY_PER_REQUEST. For more information, + // see Read/write capacity modes // (https://docs.aws.amazon.com/keyspaces/latest/devguide/ReadWriteCapacityMode.html) // in the Amazon Keyspaces Developer Guide. CapacitySpecification *types.CapacitySpecification + // Enables client-side timestamps for the table. By default, the setting is + // disabled. You can enable client-side timestamps with the following option: + // + // * + // status: "enabled" + // + // Once client-side timestamps are enabled for a table, this + // setting cannot be disabled. + ClientSideTimestamps *types.ClientSideTimestamps + // The default Time to Live setting in seconds for the table. For more information, // see Setting the default TTL value for a table // (https://docs.aws.amazon.com/keyspaces/latest/devguide/TTL-how-it-works.html#ttl-howitworks_default_ttl) @@ -64,24 +84,43 @@ type UpdateTableInput struct { DefaultTimeToLive *int32 // Modifies the encryption settings of the table. You can choose one of the - // following KMS key (KMS key): • type:AWS_OWNED_KMS_KEY - This key is owned by - // Amazon Keyspaces. • type:CUSTOMER_MANAGED_KMS_KEY - This key is stored in your + // following KMS key (KMS key): + // + // * type:AWS_OWNED_KMS_KEY - This key is owned by + // Amazon Keyspaces. + // + // * type:CUSTOMER_MANAGED_KMS_KEY - This key is stored in your // account and is created, owned, and managed by you. This option requires the - // kms_key_identifier of the KMS key in Amazon Resource Name (ARN) format as input. - // The default is AWS_OWNED_KMS_KEY. For more information, see Encryption at rest + // kms_key_identifier of the KMS key in Amazon Resource Name (ARN) format as + // input. + // + // The default is AWS_OWNED_KMS_KEY. For more information, see Encryption + // at rest // (https://docs.aws.amazon.com/keyspaces/latest/devguide/EncryptionAtRest.html) in // the Amazon Keyspaces Developer Guide. EncryptionSpecification *types.EncryptionSpecification - // Modifies the pointInTimeRecovery settings of the table. The options are: • - // ENABLED • DISABLED If it's not specified, the default is DISABLED. For more - // information, see Point-in-time recovery + // Modifies the pointInTimeRecovery settings of the table. The options are: + // + // * + // status=ENABLED + // + // * status=DISABLED + // + // If it's not specified, the default is + // status=DISABLED. For more information, see Point-in-time recovery // (https://docs.aws.amazon.com/keyspaces/latest/devguide/PointInTimeRecovery.html) // in the Amazon Keyspaces Developer Guide. PointInTimeRecovery *types.PointInTimeRecovery - // Modifies Time to Live custom settings for the table. The options are: • - // status:enabled • status:disabled The default is status:disabled. After ttl is + // Modifies Time to Live custom settings for the table. The options are: + // + // * + // status:enabled + // + // * status:disabled + // + // The default is status:disabled. After ttl is // enabled, you can't disable it for the table. For more information, see Expiring // data by using Amazon Keyspaces Time to Live (TTL) // (https://docs.aws.amazon.com/keyspaces/latest/devguide/TTL.html) in the Amazon diff --git a/service/keyspaces/deserializers.go b/service/keyspaces/deserializers.go index 0c9148434e3..e77ad70b054 100644 --- a/service/keyspaces/deserializers.go +++ b/service/keyspaces/deserializers.go @@ -1968,6 +1968,46 @@ func awsAwsjson10_deserializeDocumentCapacitySpecificationSummary(v **types.Capa return nil } +func awsAwsjson10_deserializeDocumentClientSideTimestamps(v **types.ClientSideTimestamps, 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.ClientSideTimestamps + if *v == nil { + sv = &types.ClientSideTimestamps{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "status": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ClientSideTimestampsStatus to be of type string, got %T instead", value) + } + sv.Status = types.ClientSideTimestampsStatus(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson10_deserializeDocumentClusteringKey(v **types.ClusteringKey, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -3203,6 +3243,11 @@ func awsAwsjson10_deserializeOpDocumentGetTableOutput(v **GetTableOutput, value return err } + case "clientSideTimestamps": + if err := awsAwsjson10_deserializeDocumentClientSideTimestamps(&sv.ClientSideTimestamps, value); err != nil { + return err + } + case "comment": if err := awsAwsjson10_deserializeDocumentComment(&sv.Comment, value); err != nil { return err diff --git a/service/keyspaces/doc.go b/service/keyspaces/doc.go index e2c371dde9a..18633aedbd3 100644 --- a/service/keyspaces/doc.go +++ b/service/keyspaces/doc.go @@ -11,10 +11,11 @@ // without deploying any infrastructure or installing software. In addition to // supporting Cassandra Query Language (CQL) requests via open-source Cassandra // drivers, Amazon Keyspaces supports data definition language (DDL) operations to -// manage keyspaces and tables using the Amazon Web Services SDK and CLI. This API -// reference describes the supported DDL operations in detail. For the list of all -// supported CQL APIs, see Supported Cassandra APIs, operations, and data types in -// Amazon Keyspaces +// manage keyspaces and tables using the Amazon Web Services SDK and CLI, as well +// as infrastructure as code (IaC) services and tools such as CloudFormation and +// Terraform. This API reference describes the supported DDL operations in detail. +// For the list of all supported CQL APIs, see Supported Cassandra APIs, +// operations, and data types in Amazon Keyspaces // (https://docs.aws.amazon.com/keyspaces/latest/devguide/cassandra-apis.html) in // the Amazon Keyspaces Developer Guide. To learn how Amazon Keyspaces API actions // are recorded with CloudTrail, see Amazon Keyspaces information in CloudTrail diff --git a/service/keyspaces/serializers.go b/service/keyspaces/serializers.go index 76a88838a39..fdc8b85a55b 100644 --- a/service/keyspaces/serializers.go +++ b/service/keyspaces/serializers.go @@ -752,6 +752,18 @@ func awsAwsjson10_serializeDocumentCapacitySpecification(v *types.CapacitySpecif return nil } +func awsAwsjson10_serializeDocumentClientSideTimestamps(v *types.ClientSideTimestamps, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if len(v.Status) > 0 { + ok := object.Key("status") + ok.String(string(v.Status)) + } + + return nil +} + func awsAwsjson10_serializeDocumentClusteringKey(v *types.ClusteringKey, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -1010,6 +1022,13 @@ func awsAwsjson10_serializeOpDocumentCreateTableInput(v *CreateTableInput, value } } + if v.ClientSideTimestamps != nil { + ok := object.Key("clientSideTimestamps") + if err := awsAwsjson10_serializeDocumentClientSideTimestamps(v.ClientSideTimestamps, ok); err != nil { + return err + } + } + if v.Comment != nil { ok := object.Key("comment") if err := awsAwsjson10_serializeDocumentComment(v.Comment, ok); err != nil { @@ -1305,6 +1324,13 @@ func awsAwsjson10_serializeOpDocumentUpdateTableInput(v *UpdateTableInput, value } } + if v.ClientSideTimestamps != nil { + ok := object.Key("clientSideTimestamps") + if err := awsAwsjson10_serializeDocumentClientSideTimestamps(v.ClientSideTimestamps, ok); err != nil { + return err + } + } + if v.DefaultTimeToLive != nil { ok := object.Key("defaultTimeToLive") ok.Integer(*v.DefaultTimeToLive) diff --git a/service/keyspaces/types/enums.go b/service/keyspaces/types/enums.go index acd7e0b878f..9a206e96fd1 100644 --- a/service/keyspaces/types/enums.go +++ b/service/keyspaces/types/enums.go @@ -2,6 +2,22 @@ package types +type ClientSideTimestampsStatus string + +// Enum values for ClientSideTimestampsStatus +const ( + ClientSideTimestampsStatusEnabled ClientSideTimestampsStatus = "ENABLED" +) + +// Values returns all known values for ClientSideTimestampsStatus. 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 (ClientSideTimestampsStatus) Values() []ClientSideTimestampsStatus { + return []ClientSideTimestampsStatus{ + "ENABLED", + } +} + type EncryptionType string // Enum values for EncryptionType diff --git a/service/keyspaces/types/types.go b/service/keyspaces/types/types.go index e2c9f6f9469..07b7860ac96 100644 --- a/service/keyspaces/types/types.go +++ b/service/keyspaces/types/types.go @@ -8,7 +8,13 @@ import ( ) // Amazon Keyspaces has two read/write capacity modes for processing reads and -// writes on your tables: • On-demand (default) • Provisioned The read/write +// writes on your tables: +// +// * On-demand (default) +// +// * Provisioned +// +// The read/write // capacity mode that you choose controls how you are charged for read and write // throughput and how table throughput capacity is managed. For more information, // see Read/write capacity modes @@ -16,9 +22,15 @@ import ( // in the Amazon Keyspaces Developer Guide. type CapacitySpecification struct { - // The read/write throughput capacity mode for a table. The options are: • - // throughputMode:PAY_PER_REQUEST and • throughputMode:PROVISIONED - Provisioned - // capacity mode requires readCapacityUnits and writeCapacityUnits as input. The + // The read/write throughput capacity mode for a table. The options are: + // + // * + // throughputMode:PAY_PER_REQUEST and + // + // * throughputMode:PROVISIONED - Provisioned + // capacity mode requires readCapacityUnits and writeCapacityUnits as input. + // + // The // default is throughput_mode:PAY_PER_REQUEST. For more information, see Read/write // capacity modes // (https://docs.aws.amazon.com/keyspaces/latest/devguide/ReadWriteCapacityMode.html) @@ -38,16 +50,28 @@ type CapacitySpecification struct { noSmithyDocumentSerde } -// The read/write throughput capacity mode for a table. The options are: • -// throughputMode:PAY_PER_REQUEST and • throughputMode:PROVISIONED. For more +// The read/write throughput capacity mode for a table. The options are: +// +// * +// throughputMode:PAY_PER_REQUEST and +// +// * throughputMode:PROVISIONED. +// +// For more // information, see Read/write capacity modes // (https://docs.aws.amazon.com/keyspaces/latest/devguide/ReadWriteCapacityMode.html) // in the Amazon Keyspaces Developer Guide. type CapacitySpecificationSummary struct { - // The read/write throughput capacity mode for a table. The options are: • - // throughputMode:PAY_PER_REQUEST and • throughputMode:PROVISIONED - Provisioned - // capacity mode requires readCapacityUnits and writeCapacityUnits as input. The + // The read/write throughput capacity mode for a table. The options are: + // + // * + // throughputMode:PAY_PER_REQUEST and + // + // * throughputMode:PROVISIONED - Provisioned + // capacity mode requires readCapacityUnits and writeCapacityUnits as input. + // + // The // default is throughput_mode:PAY_PER_REQUEST. For more information, see Read/write // capacity modes // (https://docs.aws.amazon.com/keyspaces/latest/devguide/ReadWriteCapacityMode.html) @@ -71,6 +95,20 @@ type CapacitySpecificationSummary struct { noSmithyDocumentSerde } +// The client-side timestamp setting of the table. For more information, see How it +// works: Amazon Keyspaces client-side timestamps +// (https://docs.aws.amazon.com/keyspaces/latest/devguide/client-side-timestamps-how-it-works.html) +// in the Amazon Keyspaces Developer Guide. +type ClientSideTimestamps struct { + + // Shows how to enable client-side timestamps settings for the specified table. + // + // This member is required. + Status ClientSideTimestampsStatus + + noSmithyDocumentSerde +} + // The optional clustering column portion of your primary key determines how the // data is clustered and sorted within each partition. type ClusteringKey struct { @@ -119,11 +157,17 @@ type Comment struct { // Amazon Keyspaces encrypts and decrypts the table data at rest transparently and // integrates with Key Management Service for storing and managing the encryption -// key. You can choose one of the following KMS keys (KMS keys): • Amazon Web +// key. You can choose one of the following KMS keys (KMS keys): +// +// * Amazon Web // Services owned key - This is the default encryption type. The key is owned by -// Amazon Keyspaces (no additional charge). • Customer managed key - This key is +// Amazon Keyspaces (no additional charge). +// +// * Customer managed key - This key is // stored in your account and is created, owned, and managed by you. You have full -// control over the customer managed key (KMS charges apply). For more information +// control over the customer managed key (KMS charges apply). +// +// For more information // about encryption at rest in Amazon Keyspaces, see Encryption at rest // (https://docs.aws.amazon.com/keyspaces/latest/devguide/EncryptionAtRest.html) in // the Amazon Keyspaces Developer Guide. For more information about KMS, see KMS @@ -133,12 +177,18 @@ type Comment struct { type EncryptionSpecification struct { // The encryption option specified for the table. You can choose one of the - // following KMS keys (KMS keys): • type:AWS_OWNED_KMS_KEY - This key is owned by - // Amazon Keyspaces. • type:CUSTOMER_MANAGED_KMS_KEY - This key is stored in your + // following KMS keys (KMS keys): + // + // * type:AWS_OWNED_KMS_KEY - This key is owned by + // Amazon Keyspaces. + // + // * type:CUSTOMER_MANAGED_KMS_KEY - This key is stored in your // account and is created, owned, and managed by you. This option requires the - // kms_key_identifier of the KMS key in Amazon Resource Name (ARN) format as input. - // The default is type:AWS_OWNED_KMS_KEY. For more information, see Encryption at - // rest + // kms_key_identifier of the KMS key in Amazon Resource Name (ARN) format as + // input. + // + // The default is type:AWS_OWNED_KMS_KEY. For more information, see + // Encryption at rest // (https://docs.aws.amazon.com/keyspaces/latest/devguide/EncryptionAtRest.html) in // the Amazon Keyspaces Developer Guide. // @@ -189,7 +239,11 @@ type PartitionKey struct { // in the Amazon Keyspaces Developer Guide. type PointInTimeRecovery struct { - // The options are: • ENABLED • DISABLED + // The options are: + // + // * status=ENABLED + // + // * status=DISABLED // // This member is required. Status PointInTimeRecoveryStatus diff --git a/service/keyspaces/validators.go b/service/keyspaces/validators.go index 76f5f87dcb5..c19dbc62d4f 100644 --- a/service/keyspaces/validators.go +++ b/service/keyspaces/validators.go @@ -313,6 +313,21 @@ func validateCapacitySpecification(v *types.CapacitySpecification) error { } } +func validateClientSideTimestamps(v *types.ClientSideTimestamps) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ClientSideTimestamps"} + if len(v.Status) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("Status")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateClusteringKey(v *types.ClusteringKey) error { if v == nil { return nil @@ -646,6 +661,11 @@ func validateOpCreateTableInput(v *CreateTableInput) error { invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) } } + if v.ClientSideTimestamps != nil { + if err := validateClientSideTimestamps(v.ClientSideTimestamps); err != nil { + invalidParams.AddNested("ClientSideTimestamps", err.(smithy.InvalidParamsError)) + } + } if invalidParams.Len() > 0 { return invalidParams } else { @@ -873,6 +893,11 @@ func validateOpUpdateTableInput(v *UpdateTableInput) error { invalidParams.AddNested("Ttl", err.(smithy.InvalidParamsError)) } } + if v.ClientSideTimestamps != nil { + if err := validateClientSideTimestamps(v.ClientSideTimestamps); err != nil { + invalidParams.AddNested("ClientSideTimestamps", err.(smithy.InvalidParamsError)) + } + } if invalidParams.Len() > 0 { return invalidParams } else {