From 6a308eb2cdb64e396a97626ffccd41e016c007a9 Mon Sep 17 00:00:00 2001 From: mattBrzezinski Date: Wed, 31 Mar 2021 06:15:06 +0000 Subject: [PATCH] AWS API Definitions Updated --- src/services/cloudwatch.jl | 124 +++++++++++++++++++++- src/services/config_service.jl | 52 +++++++++- src/services/databrew.jl | 8 +- src/services/docdb.jl | 150 +++++++++++++++++++++++++++ src/services/ec2.jl | 116 +++++++++++++++++++-- src/services/ec2_instance_connect.jl | 38 +++++-- src/services/frauddetector.jl | 67 ++++++++++++ src/services/glue.jl | 31 +++--- src/services/location.jl | 114 ++++++++++---------- src/services/sagemaker.jl | 56 +++++----- src/services/wafv2.jl | 34 +++++- 11 files changed, 669 insertions(+), 121 deletions(-) diff --git a/src/services/cloudwatch.jl b/src/services/cloudwatch.jl index 8075b5245c..6ada1682e6 100644 --- a/src/services/cloudwatch.jl +++ b/src/services/cloudwatch.jl @@ -78,6 +78,19 @@ was created might not be available. delete_insight_rules(RuleNames; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("DeleteInsightRules", Dict{String, Any}("RuleNames"=>RuleNames); aws_config=aws_config) delete_insight_rules(RuleNames, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("DeleteInsightRules", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("RuleNames"=>RuleNames), params)); aws_config=aws_config) +""" + delete_metric_stream(name) + delete_metric_stream(name, params::Dict{String,<:Any}) + +Permanently deletes the metric stream that you specify. + +# Arguments +- `name`: The name of the metric stream to delete. + +""" +delete_metric_stream(Name; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("DeleteMetricStream", Dict{String, Any}("Name"=>Name); aws_config=aws_config) +delete_metric_stream(Name, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("DeleteMetricStream", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Name"=>Name), params)); aws_config=aws_config) + """ describe_alarm_history() describe_alarm_history(params::Dict{String,<:Any}) @@ -520,6 +533,19 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys get_metric_statistics(EndTime, MetricName, Namespace, Period, StartTime; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("GetMetricStatistics", Dict{String, Any}("EndTime"=>EndTime, "MetricName"=>MetricName, "Namespace"=>Namespace, "Period"=>Period, "StartTime"=>StartTime); aws_config=aws_config) get_metric_statistics(EndTime, MetricName, Namespace, Period, StartTime, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("GetMetricStatistics", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("EndTime"=>EndTime, "MetricName"=>MetricName, "Namespace"=>Namespace, "Period"=>Period, "StartTime"=>StartTime), params)); aws_config=aws_config) +""" + get_metric_stream(name) + get_metric_stream(name, params::Dict{String,<:Any}) + +Returns information about the metric stream that you specify. + +# Arguments +- `name`: The name of the metric stream to retrieve information about. + +""" +get_metric_stream(Name; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("GetMetricStream", Dict{String, Any}("Name"=>Name); aws_config=aws_config) +get_metric_stream(Name, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("GetMetricStream", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Name"=>Name), params)); aws_config=aws_config) + """ get_metric_widget_image(metric_widget) get_metric_widget_image(metric_widget, params::Dict{String,<:Any}) @@ -581,6 +607,21 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys list_dashboards(; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("ListDashboards"; aws_config=aws_config) list_dashboards(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("ListDashboards", params; aws_config=aws_config) +""" + list_metric_streams() + list_metric_streams(params::Dict{String,<:Any}) + +Returns a list of metric streams in this account. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"MaxResults"`: The maximum number of results to return in one operation. +- `"NextToken"`: Include this value, if it was returned by the previous call, to get the + next set of metric streams. +""" +list_metric_streams(; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("ListMetricStreams"; aws_config=aws_config) +list_metric_streams(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("ListMetricStreams", params; aws_config=aws_config) + """ list_metrics() list_metrics(params::Dict{String,<:Any}) @@ -813,7 +854,7 @@ permissions for some alarm operations: The iam:CreateServiceLinkedRole for all with EC2 actions The iam:CreateServiceLinkedRole to create an alarm with Systems Manager OpsItem actions. The first time you create an alarm in the AWS Management Console, the CLI, or by using the PutMetricAlarm API, CloudWatch creates the necessary service-linked -rolea for you. The service-linked roles are called AWSServiceRoleForCloudWatchEvents and +role for you. The service-linked roles are called AWSServiceRoleForCloudWatchEvents and AWSServiceRoleForCloudWatchAlarms_ActionSSM. For more information, see AWS service-linked role. @@ -895,7 +936,8 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys endly-name:policyName/policy-friendly-name Valid Values (for use with IAM roles): arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Stop/1.0 | arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Terminate/1.0 | - arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Reboot/1.0 + arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Reboot/1.0 | + arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Recover/1.0 - `"Period"`: The length, in seconds, used each time the metric specified in MetricName is evaluated. Valid values are 10, 30, and any multiple of 60. Period is required for alarms based on static thresholds. If you are creating an alarm based on a metric math expression, @@ -988,6 +1030,54 @@ by SampleCount. put_metric_data(MetricData, Namespace; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("PutMetricData", Dict{String, Any}("MetricData"=>MetricData, "Namespace"=>Namespace); aws_config=aws_config) put_metric_data(MetricData, Namespace, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("PutMetricData", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("MetricData"=>MetricData, "Namespace"=>Namespace), params)); aws_config=aws_config) +""" + put_metric_stream(firehose_arn, name, output_format, role_arn) + put_metric_stream(firehose_arn, name, output_format, role_arn, params::Dict{String,<:Any}) + +Creates or updates a metric stream. Metric streams can automatically stream CloudWatch +metrics to AWS destinations including Amazon S3 and to many third-party solutions. For more +information, see Using Metric Streams. To create a metric stream, you must be logged on to +an account that has the iam:PassRole permission and either the CloudWatchFullAccess policy +or the cloudwatch:PutMetricStream permission. When you create or update a metric stream, +you choose one of the following: Stream metrics from all metric namespaces in the +account. Stream metrics from all metric namespaces in the account, except for the +namespaces that you list in ExcludeFilters. Stream metrics from only the metric +namespaces that you list in IncludeFilters. When you use PutMetricStream to create a new +metric stream, the stream is created in the running state. If you use it to update an +existing stream, the state of the stream is not changed. + +# Arguments +- `firehose_arn`: The ARN of the Amazon Kinesis Firehose delivery stream to use for this + metric stream. This Amazon Kinesis Firehose delivery stream must already exist and must be + in the same account as the metric stream. +- `name`: If you are creating a new metric stream, this is the name for the new stream. The + name must be different than the names of other metric streams in this account and Region. + If you are updating a metric stream, specify the name of that stream here. Valid characters + are A-Z, a-z, 0-9, \"-\" and \"_\". +- `output_format`: The output format for the stream. Valid values are json and + opentelemetry0.7. For more information about metric stream output formats, see Metric + streams output formats. +- `role_arn`: The ARN of an IAM role that this metric stream will use to access Amazon + Kinesis Firehose resources. This IAM role must already exist and must be in the same + account as the metric stream. This IAM role must include the following permissions: + firehose:PutRecord firehose:PutRecordBatch + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"ExcludeFilters"`: If you specify this parameter, the stream sends metrics from all + metric namespaces except for the namespaces that you specify here. You cannot include + ExcludeFilters and IncludeFilters in the same operation. +- `"IncludeFilters"`: If you specify this parameter, the stream sends only the metrics from + the metric namespaces that you specify here. You cannot include IncludeFilters and + ExcludeFilters in the same operation. +- `"Tags"`: A list of key-value pairs to associate with the metric stream. You can + associate as many as 50 tags with a metric stream. Tags can help you organize and + categorize your resources. You can also use them to scope user permissions by granting a + user permission to access or change only resources with certain tag values. +""" +put_metric_stream(FirehoseArn, Name, OutputFormat, RoleArn; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("PutMetricStream", Dict{String, Any}("FirehoseArn"=>FirehoseArn, "Name"=>Name, "OutputFormat"=>OutputFormat, "RoleArn"=>RoleArn); aws_config=aws_config) +put_metric_stream(FirehoseArn, Name, OutputFormat, RoleArn, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("PutMetricStream", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("FirehoseArn"=>FirehoseArn, "Name"=>Name, "OutputFormat"=>OutputFormat, "RoleArn"=>RoleArn), params)); aws_config=aws_config) + """ set_alarm_state(alarm_name, state_reason, state_value) set_alarm_state(alarm_name, state_reason, state_value, params::Dict{String,<:Any}) @@ -1020,6 +1110,36 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys set_alarm_state(AlarmName, StateReason, StateValue; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("SetAlarmState", Dict{String, Any}("AlarmName"=>AlarmName, "StateReason"=>StateReason, "StateValue"=>StateValue); aws_config=aws_config) set_alarm_state(AlarmName, StateReason, StateValue, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("SetAlarmState", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("AlarmName"=>AlarmName, "StateReason"=>StateReason, "StateValue"=>StateValue), params)); aws_config=aws_config) +""" + start_metric_streams(names) + start_metric_streams(names, params::Dict{String,<:Any}) + +Starts the streaming of metrics for one or more of your metric streams. + +# Arguments +- `names`: The array of the names of metric streams to start streaming. This is an \"all or + nothing\" operation. If you do not have permission to access all of the metric streams that + you list here, then none of the streams that you list in the operation will start streaming. + +""" +start_metric_streams(Names; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("StartMetricStreams", Dict{String, Any}("Names"=>Names); aws_config=aws_config) +start_metric_streams(Names, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("StartMetricStreams", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Names"=>Names), params)); aws_config=aws_config) + +""" + stop_metric_streams(names) + stop_metric_streams(names, params::Dict{String,<:Any}) + +Stops the streaming of metrics for one or more of your metric streams. + +# Arguments +- `names`: The array of the names of metric streams to stop streaming. This is an \"all or + nothing\" operation. If you do not have permission to access all of the metric streams that + you list here, then none of the streams that you list in the operation will stop streaming. + +""" +stop_metric_streams(Names; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("StopMetricStreams", Dict{String, Any}("Names"=>Names); aws_config=aws_config) +stop_metric_streams(Names, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudwatch("StopMetricStreams", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Names"=>Names), params)); aws_config=aws_config) + """ tag_resource(resource_arn, tags) tag_resource(resource_arn, tags, params::Dict{String,<:Any}) diff --git a/src/services/config_service.jl b/src/services/config_service.jl index 9173ca0b36..a01b32c233 100644 --- a/src/services/config_service.jl +++ b/src/services/config_service.jl @@ -328,6 +328,29 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys describe_aggregate_compliance_by_config_rules(ConfigurationAggregatorName; aws_config::AbstractAWSConfig=global_aws_config()) = config_service("DescribeAggregateComplianceByConfigRules", Dict{String, Any}("ConfigurationAggregatorName"=>ConfigurationAggregatorName); aws_config=aws_config) describe_aggregate_compliance_by_config_rules(ConfigurationAggregatorName, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = config_service("DescribeAggregateComplianceByConfigRules", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("ConfigurationAggregatorName"=>ConfigurationAggregatorName), params)); aws_config=aws_config) +""" + describe_aggregate_compliance_by_conformance_packs(configuration_aggregator_name) + describe_aggregate_compliance_by_conformance_packs(configuration_aggregator_name, params::Dict{String,<:Any}) + +Returns a list of the conformance packs and their associated compliance status with the +count of compliant and noncompliant AWS Config rules within each conformance pack. The +results can return an empty result page, but if you have a nextToken, the results are +displayed on the next page. + +# Arguments +- `configuration_aggregator_name`: The name of the configuration aggregator. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"Filters"`: Filters the result by AggregateConformancePackComplianceFilters object. +- `"Limit"`: The maximum number of conformance packs details returned on each page. The + default is maximum. If you specify 0, AWS Config uses the default. +- `"NextToken"`: The nextToken string returned on a previous page that you use to get the + next page of results in a paginated response. +""" +describe_aggregate_compliance_by_conformance_packs(ConfigurationAggregatorName; aws_config::AbstractAWSConfig=global_aws_config()) = config_service("DescribeAggregateComplianceByConformancePacks", Dict{String, Any}("ConfigurationAggregatorName"=>ConfigurationAggregatorName); aws_config=aws_config) +describe_aggregate_compliance_by_conformance_packs(ConfigurationAggregatorName, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = config_service("DescribeAggregateComplianceByConformancePacks", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("ConfigurationAggregatorName"=>ConfigurationAggregatorName), params)); aws_config=aws_config) + """ describe_aggregation_authorizations() describe_aggregation_authorizations(params::Dict{String,<:Any}) @@ -867,6 +890,31 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys get_aggregate_config_rule_compliance_summary(ConfigurationAggregatorName; aws_config::AbstractAWSConfig=global_aws_config()) = config_service("GetAggregateConfigRuleComplianceSummary", Dict{String, Any}("ConfigurationAggregatorName"=>ConfigurationAggregatorName); aws_config=aws_config) get_aggregate_config_rule_compliance_summary(ConfigurationAggregatorName, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = config_service("GetAggregateConfigRuleComplianceSummary", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("ConfigurationAggregatorName"=>ConfigurationAggregatorName), params)); aws_config=aws_config) +""" + get_aggregate_conformance_pack_compliance_summary(configuration_aggregator_name) + get_aggregate_conformance_pack_compliance_summary(configuration_aggregator_name, params::Dict{String,<:Any}) + +Returns the count of compliant and noncompliant conformance packs across all AWS Accounts +and AWS Regions. You can filter based on AWS Account ID or AWS Region. The results can +return an empty result page, but if you have a nextToken, the results are displayed on the +next page. + +# Arguments +- `configuration_aggregator_name`: The name of the configuration aggregator. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"Filters"`: Filters the results based on the + AggregateConformancePackComplianceSummaryFilters object. +- `"GroupByKey"`: Groups the result based on AWS Account ID or AWS Region. +- `"Limit"`: The maximum number of results returned on each page. The default is maximum. + If you specify 0, AWS Config uses the default. +- `"NextToken"`: The nextToken string returned on a previous page that you use to get the + next page of results in a paginated response. +""" +get_aggregate_conformance_pack_compliance_summary(ConfigurationAggregatorName; aws_config::AbstractAWSConfig=global_aws_config()) = config_service("GetAggregateConformancePackComplianceSummary", Dict{String, Any}("ConfigurationAggregatorName"=>ConfigurationAggregatorName); aws_config=aws_config) +get_aggregate_conformance_pack_compliance_summary(ConfigurationAggregatorName, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = config_service("GetAggregateConformancePackComplianceSummary", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("ConfigurationAggregatorName"=>ConfigurationAggregatorName), params)); aws_config=aws_config) + """ get_aggregate_discovered_resource_counts(configuration_aggregator_name) get_aggregate_discovered_resource_counts(configuration_aggregator_name, params::Dict{String,<:Any}) @@ -1516,7 +1564,7 @@ either the TemplateS3Uri or the TemplateBody parameter, but not both. If you pro AWS Config uses the TemplateS3Uri parameter and ignores the TemplateBody parameter. AWS Config sets the state of a conformance pack to CREATE_IN_PROGRESS and UPDATE_IN_PROGRESS until the conformance pack is created or updated. You cannot update a conformance pack -while it is in this state. You can create 6 conformance packs with 25 AWS Config rules in +while it is in this state. You can create 50 conformance packs with 25 AWS Config rules in each pack and 3 delegated administrator per organization. # Arguments @@ -1527,7 +1575,7 @@ each pack and 3 delegated administrator per organization. Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: - `"ConformancePackInputParameters"`: A list of ConformancePackInputParameter objects. - `"DeliveryS3Bucket"`: Amazon S3 bucket where AWS Config stores conformance pack - templates. This field is optional. + templates. This field is optional. If used, it must be prefixed with awsconfigconforms. - `"DeliveryS3KeyPrefix"`: The prefix for the Amazon S3 bucket. This field is optional. - `"ExcludedAccounts"`: A list of AWS accounts to be excluded from an organization conformance pack while deploying a conformance pack. diff --git a/src/services/databrew.jl b/src/services/databrew.jl index 01dc75f3cd..6ec54e6526 100644 --- a/src/services/databrew.jl +++ b/src/services/databrew.jl @@ -41,8 +41,10 @@ Creates a new DataBrew dataset. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: -- `"Format"`: Specifies the file format of a dataset created from an S3 file or folder. +- `"Format"`: The file format of a dataset that is created from an S3 file or folder. - `"FormatOptions"`: +- `"PathOptions"`: A set of options that defines how DataBrew interprets an S3 path of the + dataset. - `"Tags"`: Metadata tags to apply to this dataset. """ create_dataset(Input, Name; aws_config::AbstractAWSConfig=global_aws_config()) = databrew("POST", "/datasets", Dict{String, Any}("Input"=>Input, "Name"=>Name); aws_config=aws_config) @@ -591,8 +593,10 @@ Modifies the definition of an existing DataBrew dataset. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: -- `"Format"`: Specifies the file format of a dataset created from an S3 file or folder. +- `"Format"`: The file format of a dataset that is created from an S3 file or folder. - `"FormatOptions"`: +- `"PathOptions"`: A set of options that defines how DataBrew interprets an S3 path of the + dataset. """ update_dataset(Input, name; aws_config::AbstractAWSConfig=global_aws_config()) = databrew("PUT", "/datasets/$(name)", Dict{String, Any}("Input"=>Input); aws_config=aws_config) update_dataset(Input, name, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = databrew("PUT", "/datasets/$(name)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Input"=>Input), params)); aws_config=aws_config) diff --git a/src/services/docdb.jl b/src/services/docdb.jl index f780aa869f..28b980f14b 100644 --- a/src/services/docdb.jl +++ b/src/services/docdb.jl @@ -4,6 +4,25 @@ using AWS.AWSServices: docdb using AWS.Compat using AWS.UUIDs +""" + add_source_identifier_to_subscription(source_identifier, subscription_name) + add_source_identifier_to_subscription(source_identifier, subscription_name, params::Dict{String,<:Any}) + +Adds a source identifier to an existing event notification subscription. + +# Arguments +- `source_identifier`: The identifier of the event source to be added: If the source type + is an instance, a DBInstanceIdentifier must be provided. If the source type is a security + group, a DBSecurityGroupName must be provided. If the source type is a parameter group, a + DBParameterGroupName must be provided. If the source type is a snapshot, a + DBSnapshotIdentifier must be provided. +- `subscription_name`: The name of the Amazon DocumentDB event notification subscription + that you want to add a source identifier to. + +""" +add_source_identifier_to_subscription(SourceIdentifier, SubscriptionName; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("AddSourceIdentifierToSubscription", Dict{String, Any}("SourceIdentifier"=>SourceIdentifier, "SubscriptionName"=>SubscriptionName); aws_config=aws_config) +add_source_identifier_to_subscription(SourceIdentifier, SubscriptionName, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("AddSourceIdentifierToSubscription", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SourceIdentifier"=>SourceIdentifier, "SubscriptionName"=>SubscriptionName), params)); aws_config=aws_config) + """ add_tags_to_resource(resource_name, tag) add_tags_to_resource(resource_name, tag, params::Dict{String,<:Any}) @@ -320,6 +339,57 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys create_dbsubnet_group(DBSubnetGroupDescription, DBSubnetGroupName, SubnetIdentifier; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("CreateDBSubnetGroup", Dict{String, Any}("DBSubnetGroupDescription"=>DBSubnetGroupDescription, "DBSubnetGroupName"=>DBSubnetGroupName, "SubnetIdentifier"=>SubnetIdentifier); aws_config=aws_config) create_dbsubnet_group(DBSubnetGroupDescription, DBSubnetGroupName, SubnetIdentifier, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("CreateDBSubnetGroup", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("DBSubnetGroupDescription"=>DBSubnetGroupDescription, "DBSubnetGroupName"=>DBSubnetGroupName, "SubnetIdentifier"=>SubnetIdentifier), params)); aws_config=aws_config) +""" + create_event_subscription(sns_topic_arn, subscription_name) + create_event_subscription(sns_topic_arn, subscription_name, params::Dict{String,<:Any}) + +Creates an Amazon DocumentDB event notification subscription. This action requires a topic +Amazon Resource Name (ARN) created by using the Amazon DocumentDB console, the Amazon SNS +console, or the Amazon SNS API. To obtain an ARN with Amazon SNS, you must create a topic +in Amazon SNS and subscribe to the topic. The ARN is displayed in the Amazon SNS console. +You can specify the type of source (SourceType) that you want to be notified of. You can +also provide a list of Amazon DocumentDB sources (SourceIds) that trigger the events, and +you can provide a list of event categories (EventCategories) for events that you want to be +notified of. For example, you can specify SourceType = db-instance, SourceIds = +mydbinstance1, mydbinstance2 and EventCategories = Availability, Backup. If you specify +both the SourceType and SourceIds (such as SourceType = db-instance and SourceIdentifier = +myDBInstance1), you are notified of all the db-instance events for the specified source. If +you specify a SourceType but do not specify a SourceIdentifier, you receive notice of the +events for that source type for all your Amazon DocumentDB sources. If you do not specify +either the SourceType or the SourceIdentifier, you are notified of events generated from +all Amazon DocumentDB sources belonging to your customer account. + +# Arguments +- `sns_topic_arn`: The Amazon Resource Name (ARN) of the SNS topic created for event + notification. Amazon SNS creates the ARN when you create a topic and subscribe to it. +- `subscription_name`: The name of the subscription. Constraints: The name must be fewer + than 255 characters. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"Enabled"`: A Boolean value; set to true to activate the subscription, set to false to + create the subscription but not active it. +- `"EventCategories"`: A list of event categories for a SourceType that you want to + subscribe to. +- `"SourceIds"`: The list of identifiers of the event sources for which events are + returned. If not specified, then all sources are included in the response. An identifier + must begin with a letter and must contain only ASCII letters, digits, and hyphens; it can't + end with a hyphen or contain two consecutive hyphens. Constraints: If SourceIds are + provided, SourceType must also be provided. If the source type is an instance, a + DBInstanceIdentifier must be provided. If the source type is a security group, a + DBSecurityGroupName must be provided. If the source type is a parameter group, a + DBParameterGroupName must be provided. If the source type is a snapshot, a + DBSnapshotIdentifier must be provided. +- `"SourceType"`: The type of source that is generating the events. For example, if you + want to be notified of events generated by an instance, you would set this parameter to + db-instance. If this value is not specified, all events are returned. Valid values: + db-instance, db-cluster, db-parameter-group, db-security-group, db-snapshot, + db-cluster-snapshot +- `"Tags"`: The tags to be assigned to the event subscription. +""" +create_event_subscription(SnsTopicArn, SubscriptionName; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("CreateEventSubscription", Dict{String, Any}("SnsTopicArn"=>SnsTopicArn, "SubscriptionName"=>SubscriptionName); aws_config=aws_config) +create_event_subscription(SnsTopicArn, SubscriptionName, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("CreateEventSubscription", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SnsTopicArn"=>SnsTopicArn, "SubscriptionName"=>SubscriptionName), params)); aws_config=aws_config) + """ delete_dbcluster(dbcluster_identifier) delete_dbcluster(dbcluster_identifier, params::Dict{String,<:Any}) @@ -410,6 +480,20 @@ any DB instances. delete_dbsubnet_group(DBSubnetGroupName; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("DeleteDBSubnetGroup", Dict{String, Any}("DBSubnetGroupName"=>DBSubnetGroupName); aws_config=aws_config) delete_dbsubnet_group(DBSubnetGroupName, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("DeleteDBSubnetGroup", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("DBSubnetGroupName"=>DBSubnetGroupName), params)); aws_config=aws_config) +""" + delete_event_subscription(subscription_name) + delete_event_subscription(subscription_name, params::Dict{String,<:Any}) + +Deletes an Amazon DocumentDB event notification subscription. + +# Arguments +- `subscription_name`: The name of the Amazon DocumentDB event notification subscription + that you want to delete. + +""" +delete_event_subscription(SubscriptionName; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("DeleteEventSubscription", Dict{String, Any}("SubscriptionName"=>SubscriptionName); aws_config=aws_config) +delete_event_subscription(SubscriptionName, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("DeleteEventSubscription", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SubscriptionName"=>SubscriptionName), params)); aws_config=aws_config) + """ describe_certificates() describe_certificates(params::Dict{String,<:Any}) @@ -706,6 +790,31 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys describe_event_categories(; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("DescribeEventCategories"; aws_config=aws_config) describe_event_categories(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("DescribeEventCategories", params; aws_config=aws_config) +""" + describe_event_subscriptions() + describe_event_subscriptions(params::Dict{String,<:Any}) + +Lists all the subscription descriptions for a customer account. The description for a +subscription includes SubscriptionName, SNSTopicARN, CustomerID, SourceType, SourceID, +CreationTime, and Status. If you specify a SubscriptionName, lists the description for that +subscription. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"Filters"`: This parameter is not currently supported. +- `"Marker"`: 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. +- `"MaxRecords"`: The maximum number of records to include in the response. If more + records exist than the specified MaxRecords value, a pagination token (marker) is included + in the response so that the remaining results can be retrieved. Default: 100 Constraints: + Minimum 20, maximum 100. +- `"SubscriptionName"`: The name of the Amazon DocumentDB event notification subscription + that you want to describe. +""" +describe_event_subscriptions(; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("DescribeEventSubscriptions"; aws_config=aws_config) +describe_event_subscriptions(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("DescribeEventSubscriptions", params; aws_config=aws_config) + """ describe_events() describe_events(params::Dict{String,<:Any}) @@ -1049,6 +1158,30 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys modify_dbsubnet_group(DBSubnetGroupName, SubnetIdentifier; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("ModifyDBSubnetGroup", Dict{String, Any}("DBSubnetGroupName"=>DBSubnetGroupName, "SubnetIdentifier"=>SubnetIdentifier); aws_config=aws_config) modify_dbsubnet_group(DBSubnetGroupName, SubnetIdentifier, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("ModifyDBSubnetGroup", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("DBSubnetGroupName"=>DBSubnetGroupName, "SubnetIdentifier"=>SubnetIdentifier), params)); aws_config=aws_config) +""" + modify_event_subscription(subscription_name) + modify_event_subscription(subscription_name, params::Dict{String,<:Any}) + +Modifies an existing Amazon DocumentDB event notification subscription. + +# Arguments +- `subscription_name`: The name of the Amazon DocumentDB event notification subscription. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"Enabled"`: A Boolean value; set to true to activate the subscription. +- `"EventCategories"`: A list of event categories for a SourceType that you want to + subscribe to. +- `"SnsTopicArn"`: The Amazon Resource Name (ARN) of the SNS topic created for event + notification. The ARN is created by Amazon SNS when you create a topic and subscribe to it. +- `"SourceType"`: The type of source that is generating the events. For example, if you + want to be notified of events generated by an instance, set this parameter to db-instance. + If this value is not specified, all events are returned. Valid values: db-instance, + db-parameter-group, db-security-group, db-snapshot +""" +modify_event_subscription(SubscriptionName; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("ModifyEventSubscription", Dict{String, Any}("SubscriptionName"=>SubscriptionName); aws_config=aws_config) +modify_event_subscription(SubscriptionName, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("ModifyEventSubscription", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SubscriptionName"=>SubscriptionName), params)); aws_config=aws_config) + """ reboot_dbinstance(dbinstance_identifier) reboot_dbinstance(dbinstance_identifier, params::Dict{String,<:Any}) @@ -1071,6 +1204,23 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys reboot_dbinstance(DBInstanceIdentifier; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("RebootDBInstance", Dict{String, Any}("DBInstanceIdentifier"=>DBInstanceIdentifier); aws_config=aws_config) reboot_dbinstance(DBInstanceIdentifier, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("RebootDBInstance", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("DBInstanceIdentifier"=>DBInstanceIdentifier), params)); aws_config=aws_config) +""" + remove_source_identifier_from_subscription(source_identifier, subscription_name) + remove_source_identifier_from_subscription(source_identifier, subscription_name, params::Dict{String,<:Any}) + +Removes a source identifier from an existing Amazon DocumentDB event notification +subscription. + +# Arguments +- `source_identifier`: The source identifier to be removed from the subscription, such as + the instance identifier for an instance, or the name of a security group. +- `subscription_name`: The name of the Amazon DocumentDB event notification subscription + that you want to remove a source identifier from. + +""" +remove_source_identifier_from_subscription(SourceIdentifier, SubscriptionName; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("RemoveSourceIdentifierFromSubscription", Dict{String, Any}("SourceIdentifier"=>SourceIdentifier, "SubscriptionName"=>SubscriptionName); aws_config=aws_config) +remove_source_identifier_from_subscription(SourceIdentifier, SubscriptionName, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = docdb("RemoveSourceIdentifierFromSubscription", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SourceIdentifier"=>SourceIdentifier, "SubscriptionName"=>SubscriptionName), params)); aws_config=aws_config) + """ remove_tags_from_resource(resource_name, tag_keys) remove_tags_from_resource(resource_name, tag_keys, params::Dict{String,<:Any}) diff --git a/src/services/ec2.jl b/src/services/ec2.jl index 7941e6c57d..65521ae8fb 100644 --- a/src/services/ec2.jl +++ b/src/services/ec2.jl @@ -443,15 +443,15 @@ Associates an AWS Identity and Access Management (IAM) role with an AWS Certific (ACM) certificate. This enables the certificate to be used by the ACM for Nitro Enclaves application inside an enclave. For more information, see AWS Certificate Manager for Nitro Enclaves in the AWS Nitro Enclaves User Guide. When the IAM role is associated with the ACM -certificate, places the certificate, certificate chain, and encrypted private key in an +certificate, the certificate, certificate chain, and encrypted private key are placed in an Amazon S3 bucket that only the associated IAM role can access. The private key of the certificate is encrypted with an AWS-managed KMS customer master (CMK) that has an attached attestation-based CMK policy. To enable the IAM role to access the Amazon S3 object, you must grant it permission to call s3:GetObject on the Amazon S3 bucket returned by the command. To enable the IAM role to access the AWS KMS CMK, you must grant it permission to -call kms:Decrypt on AWS KMS CMK returned by the command. For more information, see Grant -the role permission to access the certificate and encryption key in the AWS Nitro Enclaves -User Guide. +call kms:Decrypt on the AWS KMS CMK returned by the command. For more information, see +Grant the role permission to access the certificate and encryption key in the AWS Nitro +Enclaves User Guide. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: @@ -2147,6 +2147,33 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys create_placement_group(; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("CreatePlacementGroup"; aws_config=aws_config) create_placement_group(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("CreatePlacementGroup", params; aws_config=aws_config) +""" + create_replace_root_volume_task(instance_id) + create_replace_root_volume_task(instance_id, params::Dict{String,<:Any}) + +Creates a root volume replacement task for an Amazon EC2 instance. The root volume can +either be restored to its initial launch state, or it can be restored using a specific +snapshot. For more information, see Replace a root volume in the Amazon Elastic Compute +Cloud User Guide. + +# Arguments +- `instance_id`: The ID of the instance for which to replace the root volume. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"ClientToken"`: Unique, case-sensitive identifier you provide to ensure the idempotency + of the request. If you do not specify a client token, a randomly generated token is used + for the request to ensure idempotency. For more information, see Ensuring Idempotency. +- `"DryRun"`: Checks whether you have the required permissions for the action, without + actually making the request, and provides an error response. If you have the required + permissions, the error response is DryRunOperation. Otherwise, it is UnauthorizedOperation. +- `"SnapshotId"`: The ID of the snapshot from which to restore the replacement root volume. + If you want to restore the volume to the initial launch state, omit this parameter. +- `"TagSpecification"`: The tags to apply to the root volume replacement task. +""" +create_replace_root_volume_task(InstanceId; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("CreateReplaceRootVolumeTask", Dict{String, Any}("InstanceId"=>InstanceId, "ClientToken"=>string(uuid4())); aws_config=aws_config) +create_replace_root_volume_task(InstanceId, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("CreateReplaceRootVolumeTask", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("InstanceId"=>InstanceId, "ClientToken"=>string(uuid4())), params)); aws_config=aws_config) + """ create_reserved_instances_listing(client_token, instance_count, price_schedules, reserved_instances_id) create_reserved_instances_listing(client_token, instance_count, price_schedules, reserved_instances_id, params::Dict{String,<:Any}) @@ -6568,6 +6595,28 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys describe_regions(; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("DescribeRegions"; aws_config=aws_config) describe_regions(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("DescribeRegions", params; aws_config=aws_config) +""" + describe_replace_root_volume_tasks() + describe_replace_root_volume_tasks(params::Dict{String,<:Any}) + +Describes a root volume replacement task. For more information, see Replace a root volume +in the Amazon Elastic Compute Cloud User Guide. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"DryRun"`: Checks whether you have the required permissions for the action, without + actually making the request, and provides an error response. If you have the required + permissions, the error response is DryRunOperation. Otherwise, it is UnauthorizedOperation. +- `"Filter"`: Filter to use: instance-id - The ID of the instance for which the root + volume replacement task was created. +- `"MaxResults"`: The maximum number of results to return with a single call. To retrieve + the remaining results, make another call with the returned nextToken value. +- `"NextToken"`: The token for the next page of results. +- `"ReplaceRootVolumeTaskId"`: The ID of the root volume replacement task to view. +""" +describe_replace_root_volume_tasks(; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("DescribeReplaceRootVolumeTasks"; aws_config=aws_config) +describe_replace_root_volume_tasks(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("DescribeReplaceRootVolumeTasks", params; aws_config=aws_config) + """ describe_reserved_instances() describe_reserved_instances(params::Dict{String,<:Any}) @@ -8345,6 +8394,23 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys disable_fast_snapshot_restores(AvailabilityZone, SourceSnapshotId; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("DisableFastSnapshotRestores", Dict{String, Any}("AvailabilityZone"=>AvailabilityZone, "SourceSnapshotId"=>SourceSnapshotId); aws_config=aws_config) disable_fast_snapshot_restores(AvailabilityZone, SourceSnapshotId, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("DisableFastSnapshotRestores", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("AvailabilityZone"=>AvailabilityZone, "SourceSnapshotId"=>SourceSnapshotId), params)); aws_config=aws_config) +""" + disable_serial_console_access() + disable_serial_console_access(params::Dict{String,<:Any}) + +Disables access to the EC2 serial console of all instances for your account. By default, +access to the EC2 serial console is disabled for your account. For more information, see +Manage account access to the EC2 serial console in the Amazon EC2 User Guide. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"DryRun"`: Checks whether you have the required permissions for the action, without + actually making the request, and provides an error response. If you have the required + permissions, the error response is DryRunOperation. Otherwise, it is UnauthorizedOperation. +""" +disable_serial_console_access(; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("DisableSerialConsoleAccess"; aws_config=aws_config) +disable_serial_console_access(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("DisableSerialConsoleAccess", params; aws_config=aws_config) + """ disable_transit_gateway_route_table_propagation(transit_gateway_attachment_id, transit_gateway_route_table_id) disable_transit_gateway_route_table_propagation(transit_gateway_attachment_id, transit_gateway_route_table_id, params::Dict{String,<:Any}) @@ -8598,8 +8664,8 @@ disassociate_vpc_cidr_block(associationId, params::AbstractDict{String, <:Any}; enable_ebs_encryption_by_default(params::Dict{String,<:Any}) Enables EBS encryption by default for your account in the current Region. After you enable -encryption by default, the EBS volumes that you create are are always encrypted, either -using the default CMK or the CMK that you specified when you created each volume. For more +encryption by default, the EBS volumes that you create are always encrypted, either using +the default CMK or the CMK that you specified when you created each volume. For more information, see Amazon EBS encryption in the Amazon Elastic Compute Cloud User Guide. You can specify the default CMK for encryption by default using ModifyEbsDefaultKmsKeyId or ResetEbsDefaultKmsKeyId. Enabling encryption by default has no effect on the encryption @@ -8642,6 +8708,23 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys enable_fast_snapshot_restores(AvailabilityZone, SourceSnapshotId; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("EnableFastSnapshotRestores", Dict{String, Any}("AvailabilityZone"=>AvailabilityZone, "SourceSnapshotId"=>SourceSnapshotId); aws_config=aws_config) enable_fast_snapshot_restores(AvailabilityZone, SourceSnapshotId, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("EnableFastSnapshotRestores", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("AvailabilityZone"=>AvailabilityZone, "SourceSnapshotId"=>SourceSnapshotId), params)); aws_config=aws_config) +""" + enable_serial_console_access() + enable_serial_console_access(params::Dict{String,<:Any}) + +Enables access to the EC2 serial console of all instances for your account. By default, +access to the EC2 serial console is disabled for your account. For more information, see +Manage account access to the EC2 serial console in the Amazon EC2 User Guide. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"DryRun"`: Checks whether you have the required permissions for the action, without + actually making the request, and provides an error response. If you have the required + permissions, the error response is DryRunOperation. Otherwise, it is UnauthorizedOperation. +""" +enable_serial_console_access(; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("EnableSerialConsoleAccess"; aws_config=aws_config) +enable_serial_console_access(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("EnableSerialConsoleAccess", params; aws_config=aws_config) + """ enable_transit_gateway_route_table_propagation(transit_gateway_attachment_id, transit_gateway_route_table_id) enable_transit_gateway_route_table_propagation(transit_gateway_attachment_id, transit_gateway_route_table_id, params::Dict{String,<:Any}) @@ -9207,6 +9290,24 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys get_reserved_instances_exchange_quote(ReservedInstanceId; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("GetReservedInstancesExchangeQuote", Dict{String, Any}("ReservedInstanceId"=>ReservedInstanceId); aws_config=aws_config) get_reserved_instances_exchange_quote(ReservedInstanceId, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("GetReservedInstancesExchangeQuote", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("ReservedInstanceId"=>ReservedInstanceId), params)); aws_config=aws_config) +""" + get_serial_console_access_status() + get_serial_console_access_status(params::Dict{String,<:Any}) + +Retrieves the access status of your account to the EC2 serial console of all instances. By +default, access to the EC2 serial console is disabled for your account. For more +information, see Manage account access to the EC2 serial console in the Amazon EC2 User +Guide. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"DryRun"`: Checks whether you have the required permissions for the action, without + actually making the request, and provides an error response. If you have the required + permissions, the error response is DryRunOperation. Otherwise, it is UnauthorizedOperation. +""" +get_serial_console_access_status(; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("GetSerialConsoleAccessStatus"; aws_config=aws_config) +get_serial_console_access_status(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = ec2("GetSerialConsoleAccessStatus", params; aws_config=aws_config) + """ get_transit_gateway_attachment_propagations(transit_gateway_attachment_id) get_transit_gateway_attachment_propagations(transit_gateway_attachment_id, params::Dict{String,<:Any}) @@ -10547,7 +10648,8 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys - `"Iops"`: The target IOPS rate of the volume. This parameter is valid only for gp3, io1, and io2 volumes. The following are the supported values for each volume type: gp3: 3,000-16,000 IOPS io1: 100-64,000 IOPS io2: 100-64,000 IOPS Default: If no IOPS - value is specified, the existing value is retained. + value is specified, the existing value is retained, unless a volume type is modified that + supports different values. - `"MultiAttachEnabled"`: Specifies whether to enable Amazon EBS Multi-Attach. If you enable Multi-Attach, you can attach the volume to up to 16 Nitro-based instances in the same Availability Zone. This parameter is supported with io1 and io2 volumes only. For more diff --git a/src/services/ec2_instance_connect.jl b/src/services/ec2_instance_connect.jl index fe5b760672..aa76213682 100644 --- a/src/services/ec2_instance_connect.jl +++ b/src/services/ec2_instance_connect.jl @@ -4,19 +4,43 @@ using AWS.AWSServices: ec2_instance_connect using AWS.Compat using AWS.UUIDs +""" + send_serial_console_sshpublic_key(instance_id, sshpublic_key) + send_serial_console_sshpublic_key(instance_id, sshpublic_key, params::Dict{String,<:Any}) + +Pushes an SSH public key to the specified EC2 instance. The key remains for 60 seconds, +which gives you 60 seconds to establish a serial console connection to the instance using +SSH. For more information, see EC2 Serial Console in the Amazon EC2 User Guide. + +# Arguments +- `instance_id`: The ID of the EC2 instance. +- `sshpublic_key`: The public key material. To use the public key, you must have the + matching private key. For information about the supported key formats and lengths, see + Requirements for key pairs in the Amazon EC2 User Guide. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"SerialPort"`: The serial port of the EC2 instance. Currently only port 0 is supported. + Default: 0 +""" +send_serial_console_sshpublic_key(InstanceId, SSHPublicKey; aws_config::AbstractAWSConfig=global_aws_config()) = ec2_instance_connect("SendSerialConsoleSSHPublicKey", Dict{String, Any}("InstanceId"=>InstanceId, "SSHPublicKey"=>SSHPublicKey); aws_config=aws_config) +send_serial_console_sshpublic_key(InstanceId, SSHPublicKey, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = ec2_instance_connect("SendSerialConsoleSSHPublicKey", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("InstanceId"=>InstanceId, "SSHPublicKey"=>SSHPublicKey), params)); aws_config=aws_config) + """ send_sshpublic_key(availability_zone, instance_id, instance_osuser, sshpublic_key) send_sshpublic_key(availability_zone, instance_id, instance_osuser, sshpublic_key, params::Dict{String,<:Any}) -Pushes an SSH public key to a particular OS user on a given EC2 instance for 60 seconds. +Pushes an SSH public key to the specified EC2 instance for use by the specified user. The +key remains for 60 seconds. For more information, see Connect to your Linux instance using +EC2 Instance Connect in the Amazon EC2 User Guide. # Arguments -- `availability_zone`: The availability zone the EC2 instance was launched in. -- `instance_id`: The EC2 instance you wish to publish the SSH key to. -- `instance_osuser`: The OS user on the EC2 instance whom the key may be used to - authenticate as. -- `sshpublic_key`: The public key to be published to the instance. To use it after - publication you must have the matching private key. +- `availability_zone`: The Availability Zone in which the EC2 instance was launched. +- `instance_id`: The ID of the EC2 instance. +- `instance_osuser`: The OS user on the EC2 instance for whom the key can be used to + authenticate. +- `sshpublic_key`: The public key material. To use the public key, you must have the + matching private key. """ send_sshpublic_key(AvailabilityZone, InstanceId, InstanceOSUser, SSHPublicKey; aws_config::AbstractAWSConfig=global_aws_config()) = ec2_instance_connect("SendSSHPublicKey", Dict{String, Any}("AvailabilityZone"=>AvailabilityZone, "InstanceId"=>InstanceId, "InstanceOSUser"=>InstanceOSUser, "SSHPublicKey"=>SSHPublicKey); aws_config=aws_config) diff --git a/src/services/frauddetector.jl b/src/services/frauddetector.jl index 0f4a04ab53..1d269adf3c 100644 --- a/src/services/frauddetector.jl +++ b/src/services/frauddetector.jl @@ -33,6 +33,41 @@ Gets a batch of variables. batch_get_variable(names; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("BatchGetVariable", Dict{String, Any}("names"=>names); aws_config=aws_config) batch_get_variable(names, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("BatchGetVariable", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("names"=>names), params)); aws_config=aws_config) +""" + cancel_batch_prediction_job(job_id) + cancel_batch_prediction_job(job_id, params::Dict{String,<:Any}) + +Cancels the specified batch prediction job. + +# Arguments +- `job_id`: The ID of the batch prediction job to cancel. + +""" +cancel_batch_prediction_job(jobId; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("CancelBatchPredictionJob", Dict{String, Any}("jobId"=>jobId); aws_config=aws_config) +cancel_batch_prediction_job(jobId, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("CancelBatchPredictionJob", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("jobId"=>jobId), params)); aws_config=aws_config) + +""" + create_batch_prediction_job(detector_name, event_type_name, iam_role_arn, input_path, job_id, output_path) + create_batch_prediction_job(detector_name, event_type_name, iam_role_arn, input_path, job_id, output_path, params::Dict{String,<:Any}) + +Creates a batch prediction job. + +# Arguments +- `detector_name`: The name of the detector. +- `event_type_name`: The name of the event type. +- `iam_role_arn`: The ARN of the IAM role to use for this job request. +- `input_path`: The Amazon S3 location of your training file. +- `job_id`: The ID of the batch prediction job. +- `output_path`: The Amazon S3 location of your output file. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"detectorVersion"`: The detector version. +- `"tags"`: A collection of key and value pairs. +""" +create_batch_prediction_job(detectorName, eventTypeName, iamRoleArn, inputPath, jobId, outputPath; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("CreateBatchPredictionJob", Dict{String, Any}("detectorName"=>detectorName, "eventTypeName"=>eventTypeName, "iamRoleArn"=>iamRoleArn, "inputPath"=>inputPath, "jobId"=>jobId, "outputPath"=>outputPath); aws_config=aws_config) +create_batch_prediction_job(detectorName, eventTypeName, iamRoleArn, inputPath, jobId, outputPath, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("CreateBatchPredictionJob", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("detectorName"=>detectorName, "eventTypeName"=>eventTypeName, "iamRoleArn"=>iamRoleArn, "inputPath"=>inputPath, "jobId"=>jobId, "outputPath"=>outputPath), params)); aws_config=aws_config) + """ create_detector_version(detector_id, rules) create_detector_version(detector_id, rules, params::Dict{String,<:Any}) @@ -149,6 +184,19 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys create_variable(dataSource, dataType, defaultValue, name; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("CreateVariable", Dict{String, Any}("dataSource"=>dataSource, "dataType"=>dataType, "defaultValue"=>defaultValue, "name"=>name); aws_config=aws_config) create_variable(dataSource, dataType, defaultValue, name, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("CreateVariable", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("dataSource"=>dataSource, "dataType"=>dataType, "defaultValue"=>defaultValue, "name"=>name), params)); aws_config=aws_config) +""" + delete_batch_prediction_job(job_id) + delete_batch_prediction_job(job_id, params::Dict{String,<:Any}) + +Deletes a batch prediction job. + +# Arguments +- `job_id`: The ID of the batch prediction job to delete. + +""" +delete_batch_prediction_job(jobId; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("DeleteBatchPredictionJob", Dict{String, Any}("jobId"=>jobId); aws_config=aws_config) +delete_batch_prediction_job(jobId, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("DeleteBatchPredictionJob", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("jobId"=>jobId), params)); aws_config=aws_config) + """ delete_detector(detector_id) delete_detector(detector_id, params::Dict{String,<:Any}) @@ -374,6 +422,25 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys describe_model_versions(; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("DescribeModelVersions"; aws_config=aws_config) describe_model_versions(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("DescribeModelVersions", params; aws_config=aws_config) +""" + get_batch_prediction_jobs() + get_batch_prediction_jobs(params::Dict{String,<:Any}) + +Gets all batch prediction jobs or a specific job if you specify a job ID. This is a +paginated API. If you provide a null maxResults, this action retrieves a maximum of 50 +records per page. If you provide a maxResults, the value must be between 1 and 50. To get +the next page results, provide the pagination token from the GetBatchPredictionJobsResponse +as part of your request. A null pagination token fetches the records from the beginning. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"jobId"`: The batch prediction job for which to get the details. +- `"maxResults"`: The maximum number of objects to return for the request. +- `"nextToken"`: The next token from the previous request. +""" +get_batch_prediction_jobs(; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("GetBatchPredictionJobs"; aws_config=aws_config) +get_batch_prediction_jobs(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = frauddetector("GetBatchPredictionJobs", params; aws_config=aws_config) + """ get_detector_version(detector_id, detector_version_id) get_detector_version(detector_id, detector_version_id, params::Dict{String,<:Any}) diff --git a/src/services/glue.jl b/src/services/glue.jl index 539786efdf..81f9e37afb 100644 --- a/src/services/glue.jl +++ b/src/services/glue.jl @@ -1764,11 +1764,10 @@ get_registry(RegistryId, params::AbstractDict{String, <:Any}; aws_config::Abstra get_resource_policies() get_resource_policies(params::Dict{String,<:Any}) -Retrieves the security configurations for the resource policies set on individual -resources, and also the account-level policy. This operation also returns the Data Catalog -resource policy. However, if you enabled metadata encryption in Data Catalog settings, and -you do not have permission on the AWS KMS key, the operation can't return the Data Catalog -resource policy. +Retrieves the resource policies set on individual resources by AWS Resource Access Manager +during cross-account permission grants. Also retrieves the Data Catalog resource policy. If +you enabled metadata encryption in Data Catalog settings, and you do not have permission on +the AWS KMS key, the operation can't return the Data Catalog resource policy. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: @@ -1786,9 +1785,10 @@ Retrieves a specified resource policy. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: -- `"ResourceArn"`: The ARN of the AWS Glue resource for the resource policy to be - retrieved. For more information about AWS Glue resource ARNs, see the AWS Glue ARN string - pattern +- `"ResourceArn"`: The ARN of the AWS Glue resource for which to retrieve the resource + policy. If not supplied, the Data Catalog resource policy is returned. Use + GetResourcePolicies to view all existing resource policies. For more information see + Specifying AWS Glue Resource ARNs. """ get_resource_policy(; aws_config::AbstractAWSConfig=global_aws_config()) = glue("GetResourcePolicy"; aws_config=aws_config) get_resource_policy(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = glue("GetResourcePolicy", params; aws_config=aws_config) @@ -2349,19 +2349,18 @@ Sets the Data Catalog resource policy for access control. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: -- `"EnableHybrid"`: Allows you to specify if you want to use both resource-level and - account/catalog-level resource policies. A resource-level policy is a policy attached to an - individual resource such as a database or a table. The default value of NO indicates that - resource-level policies cannot co-exist with an account-level policy. A value of YES means - the use of both resource-level and account/catalog-level resource policies is allowed. +- `"EnableHybrid"`: If 'TRUE', indicates that you are using both methods to grant + cross-account access to Data Catalog resources: By directly updating the resource policy + with PutResourePolicy By using the Grant permissions command on the AWS Management + Console. Must be set to 'TRUE' if you have already used the Management Console to grant + cross-account access, otherwise the call fails. Default is 'FALSE'. - `"PolicyExistsCondition"`: A value of MUST_EXIST is used to update a policy. A value of NOT_EXIST is used to create a new policy. If a value of NONE or a null value is used, the - call will not depend on the existence of a policy. + call does not depend on the existence of a policy. - `"PolicyHashCondition"`: The hash value returned when the previous policy was set using PutResourcePolicy. Its purpose is to prevent concurrent modifications of a policy. Do not use this parameter if no previous policy has been set. -- `"ResourceArn"`: The ARN of the AWS Glue resource for the resource policy to be set. For - more information about AWS Glue resource ARNs, see the AWS Glue ARN string pattern +- `"ResourceArn"`: Do not use. For internal use only. """ put_resource_policy(PolicyInJson; aws_config::AbstractAWSConfig=global_aws_config()) = glue("PutResourcePolicy", Dict{String, Any}("PolicyInJson"=>PolicyInJson); aws_config=aws_config) put_resource_policy(PolicyInJson, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = glue("PutResourcePolicy", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("PolicyInJson"=>PolicyInJson), params)); aws_config=aws_config) diff --git a/src/services/location.jl b/src/services/location.jl index 2e9917d32e..9b77757873 100644 --- a/src/services/location.jl +++ b/src/services/location.jl @@ -10,6 +10,8 @@ using AWS.UUIDs Creates an association between a geofence collection and a tracker resource. This allows the tracker resource to communicate location data to the linked geofence collection. +Currently not supported — Cross-account configurations, such as creating associations +between a tracker resource in one account and a geofence collection in another account. # Arguments - `consumer_arn`: The Amazon Resource Name (ARN) for the geofence collection to be @@ -41,8 +43,11 @@ batch_delete_geofence(CollectionName, GeofenceIds, params::AbstractDict{String, batch_evaluate_geofences(collection_name, device_position_updates) batch_evaluate_geofences(collection_name, device_position_updates, params::Dict{String,<:Any}) -Used in geofence monitoring. Evaluates device positions against the position of geofences -in a given geofence collection. +Evaluates device positions against the geofence geometries from a given geofence +collection. The evaluation determines if the device has entered or exited a geofenced area, +which publishes ENTER or EXIT geofence events to Amazon EventBridge. The last geofence +that a device was observed within, if any, is tracked for 30 days after the most recent +device position update # Arguments - `collection_name`: The geofence collection used in evaluating the position of devices @@ -58,8 +63,7 @@ batch_evaluate_geofences(CollectionName, DevicePositionUpdates, params::Abstract batch_get_device_position(device_ids, tracker_name) batch_get_device_position(device_ids, tracker_name, params::Dict{String,<:Any}) -A batch request to retrieve device positions. The response will return the device -positions from the last 24 hours. +A batch request to retrieve all device positions. # Arguments - `device_ids`: Devices whose position you want to retrieve. For example, for two @@ -74,7 +78,7 @@ batch_get_device_position(DeviceIds, TrackerName, params::AbstractDict{String, < batch_put_geofence(collection_name, entries) batch_put_geofence(collection_name, entries, params::Dict{String,<:Any}) -A batch request for storing geofences into a given geofence collection. +A batch request for storing geofence geometries into a given geofence collection. # Arguments - `collection_name`: The geofence collection storing the geofences. @@ -88,10 +92,10 @@ batch_put_geofence(CollectionName, Entries, params::AbstractDict{String, <:Any}; batch_update_device_position(tracker_name, updates) batch_update_device_position(tracker_name, updates, params::Dict{String,<:Any}) -Uploads a position update for one or more devices to a tracker resource. The data is used -for API queries requesting the device position and position history. Limitation — -Location data is sampled at a fixed rate of 1 position per 30 second interval, and retained -for 1 year before it is deleted. +Uploads position update data for one or more devices to a tracker resource. Amazon Location +uses the data when reporting the last known device position and position history. Only one +position update is stored per sample time. Location data is sampled at a fixed rate of one +position per 30-second interval, and retained for one year before it is deleted. # Arguments - `tracker_name`: The name of the tracker resource to update. @@ -109,19 +113,21 @@ Creates a geofence collection, which manages and stores geofences. # Arguments - `collection_name`: A custom name for the geofence collection. Requirements: Contain - only alphanumeric characters (A–Z, a–z, 0-9), hyphens (-), and underscores (_). Must - be a unique geofence collection name. No spaces allowed. For example, + only alphanumeric characters (A–Z, a–z, 0-9), hyphens (-), periods (.), and underscores + (_). Must be a unique geofence collection name. No spaces allowed. For example, ExampleGeofenceCollection. -- `pricing_plan`: Specifies the pricing plan for your geofence collection. There's three - pricing plan options: RequestBasedUsage — Selects the \"Request-Based Usage\" pricing - plan. MobileAssetTracking — Selects the \"Mobile Asset Tracking\" pricing plan. - MobileAssetManagement — Selects the \"Mobile Asset Management\" pricing plan. For - additional details and restrictions on each pricing plan option, see the Amazon Location - Service pricing page. +- `pricing_plan`: Specifies the pricing plan for your geofence collection. For additional + details and restrictions on each pricing plan option, see the Amazon Location Service + pricing page. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: - `"Description"`: An optional description for the geofence collection. +- `"PricingPlanDataSource"`: Specifies the plan data source. Required if the Mobile Asset + Tracking (MAT) or the Mobile Asset Management (MAM) pricing plan is selected. Billing is + determined by the resource usage, the associated pricing plan, and the data source that was + specified. For more information about each pricing plan option and restrictions, see the + Amazon Location Service pricing page. Valid Values: Esri | Here """ create_geofence_collection(CollectionName, PricingPlan; aws_config::AbstractAWSConfig=global_aws_config()) = location("POST", "/geofencing/v0/collections", Dict{String, Any}("CollectionName"=>CollectionName, "PricingPlan"=>PricingPlan); aws_config=aws_config) create_geofence_collection(CollectionName, PricingPlan, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = location("POST", "/geofencing/v0/collections", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("CollectionName"=>CollectionName, "PricingPlan"=>PricingPlan), params)); aws_config=aws_config) @@ -139,14 +145,10 @@ Service Terms for Amazon Location Service. # Arguments - `configuration`: Specifies the map style selected from an available data provider. - `map_name`: The name for the map resource. Requirements: Must contain only alphanumeric - characters (A–Z, a–z, 0–9), hyphens (-), and underscores (_). Must be a unique map - resource name. No spaces allowed. For example, ExampleMap. -- `pricing_plan`: Specifies the pricing plan for your map resource. There's three pricing - plan options: RequestBasedUsage — Selects the \"Request-Based Usage\" pricing plan. - MobileAssetTracking — Selects the \"Mobile Asset Tracking\" pricing plan. - MobileAssetManagement — Selects the \"Mobile Asset Management\" pricing plan. For - additional details and restrictions on each pricing plan option, see the Amazon Location - Service pricing page. + characters (A–Z, a–z, 0–9), hyphens (-), periods (.), and underscores (_). Must be + a unique map resource name. No spaces allowed. For example, ExampleMap. +- `pricing_plan`: Specifies the pricing plan for your map resource. For additional details + and restrictions on each pricing plan option, see the Amazon Location Service pricing page. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: @@ -167,16 +169,17 @@ limitations, you may not use HERE to store results for locations in Japan. For m information, see the AWS Service Terms for Amazon Location Service. # Arguments -- `data_source`: Specifies the data provider of geospatial data. +- `data_source`: Specifies the data provider of geospatial data. This field is + case-sensitive. Enter the valid values as shown. For example, entering HERE will return an + error. Valid values include: Esri Here For additional details on data providers, + see the Amazon Location Service data providers page. - `index_name`: The name of the Place index resource. Requirements: Contain only - alphanumeric characters (A-Z, a-z, 0-9) , hyphens (-) and underscores (_) ). Must be a - unique Place index resource name. No spaces allowed. For example, ExamplePlaceIndex. -- `pricing_plan`: Specifies the pricing plan for your Place index resource. There's three - pricing plan options: RequestBasedUsage — Selects the \"Request-Based Usage\" pricing - plan. MobileAssetTracking — Selects the \"Mobile Asset Tracking\" pricing plan. - MobileAssetManagement — Selects the \"Mobile Asset Management\" pricing plan. For - additional details and restrictions on each pricing plan option, see the Amazon Location - Service pricing page. + alphanumeric characters (A-Z, a-z, 0-9) , hyphens (-), periods (.), and underscores (_). + Must be a unique Place index resource name. No spaces allowed. For example, + ExamplePlaceIndex. +- `pricing_plan`: Specifies the pricing plan for your Place index resource. For additional + details and restrictions on each pricing plan option, see the Amazon Location Service + pricing page. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: @@ -194,19 +197,21 @@ Creates a tracker resource in your AWS account, which lets you retrieve current historical location of devices. # Arguments -- `pricing_plan`: Specifies the pricing plan for your tracker resource. There's three - pricing plan options: RequestBasedUsage — Selects the \"Request-Based Usage\" pricing - plan. MobileAssetTracking — Selects the \"Mobile Asset Tracking\" pricing plan. - MobileAssetManagement — Selects the \"Mobile Asset Management\" pricing plan. For - additional details and restrictions on each pricing plan option, see the Amazon Location - Service pricing page. +- `pricing_plan`: Specifies the pricing plan for your tracker resource. For additional + details and restrictions on each pricing plan option, see the Amazon Location Service + pricing page. - `tracker_name`: The name for the tracker resource. Requirements: Contain only - alphanumeric characters (A-Z, a-z, 0-9) , hyphens (-) and underscores (_). Must be a - unique tracker resource name. No spaces allowed. For example, ExampleTracker. + alphanumeric characters (A-Z, a-z, 0-9) , hyphens (-), periods (.), and underscores (_). + Must be a unique tracker resource name. No spaces allowed. For example, ExampleTracker. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: - `"Description"`: An optional description for the tracker resource. +- `"PricingPlanDataSource"`: Specifies the plan data source. Required if the Mobile Asset + Tracking (MAT) or the Mobile Asset Management (MAM) pricing plan is selected. Billing is + determined by the resource usage, the associated pricing plan, and data source that was + specified. For more information about each pricing plan option and restrictions, see the + Amazon Location Service pricing page. Valid Values: Esri | Here """ create_tracker(PricingPlan, TrackerName; aws_config::AbstractAWSConfig=global_aws_config()) = location("POST", "/tracking/v0/trackers", Dict{String, Any}("PricingPlan"=>PricingPlan, "TrackerName"=>TrackerName); aws_config=aws_config) create_tracker(PricingPlan, TrackerName, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = location("POST", "/tracking/v0/trackers", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("PricingPlan"=>PricingPlan, "TrackerName"=>TrackerName), params)); aws_config=aws_config) @@ -327,7 +332,7 @@ describe_tracker(TrackerName, params::AbstractDict{String, <:Any}; aws_config::A disassociate_tracker_consumer(consumer_arn, tracker_name) disassociate_tracker_consumer(consumer_arn, tracker_name, params::Dict{String,<:Any}) -Removes the association bewteen a tracker resource and a geofence collection. Once you +Removes the association between a tracker resource and a geofence collection. Once you unlink a tracker resource from a geofence collection, the tracker positions will no longer be automatically evaluated against geofences. @@ -346,11 +351,11 @@ disassociate_tracker_consumer(ConsumerArn, TrackerName, params::AbstractDict{Str get_device_position(device_id, tracker_name) get_device_position(device_id, tracker_name, params::Dict{String,<:Any}) -Retrieves the latest device position. Limitation — Device positions are deleted after -one year. +Retrieves a device's most recent position according to its sample time. Device positions +are deleted after one year. # Arguments -- `device_id`: The device whose position you want to retreieve. +- `device_id`: The device whose position you want to retrieve. - `tracker_name`: The tracker resource receiving the position update. """ @@ -362,7 +367,7 @@ get_device_position(DeviceId, TrackerName, params::AbstractDict{String, <:Any}; get_device_position_history(device_id, tracker_name, params::Dict{String,<:Any}) Retrieves the device position history from a tracker resource within a specified range of -time. Limitation — Device positions are deleted after one year. +time. Device positions are deleted after 1 year. # Arguments - `device_id`: The device whose position history you want to retrieve. @@ -372,13 +377,15 @@ time. Limitation — Device positions are deleted after one year. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: - `"EndTimeExclusive"`: Specify the end time for the position history in ISO 8601 format: - YYYY-MM-DDThh:mm:ss.sssZ. The given time for EndTimeExclusive must be after the time for + YYYY-MM-DDThh:mm:ss.sssZ. By default, the value will be the time that the request is made. + Requirement: The time specified for EndTimeExclusive must be after the time for StartTimeInclusive. - `"NextToken"`: The pagination token specifying which page of results to return in the response. If no token is provided, the default page is the first page. Default value: null - `"StartTimeInclusive"`: Specify the start time for the position history in ISO 8601 - format: YYYY-MM-DDThh:mm:ss.sssZ. The given time for EndTimeExclusive must be after the - time for StartTimeInclusive. + format: YYYY-MM-DDThh:mm:ss.sssZ. By default, the value will be 24 hours prior to the time + that the request is made. Requirement: The time specified for StartTimeInclusive must be + before EndTimeExclusive. """ get_device_position_history(DeviceId, TrackerName; aws_config::AbstractAWSConfig=global_aws_config()) = location("POST", "/tracking/v0/trackers/$(TrackerName)/devices/$(DeviceId)/list-positions"; aws_config=aws_config) get_device_position_history(DeviceId, TrackerName, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = location("POST", "/tracking/v0/trackers/$(TrackerName)/devices/$(DeviceId)/list-positions", params; aws_config=aws_config) @@ -575,13 +582,14 @@ list_trackers(params::AbstractDict{String, Any}; aws_config::AbstractAWSConfig=g put_geofence(collection_name, geofence_id, geometry) put_geofence(collection_name, geofence_id, geometry, params::Dict{String,<:Any}) -Stores a geofence to a given geofence collection, or updates the geometry of an existing -geofence if a geofence ID is included in the request. +Stores a geofence geometry in a given geofence collection, or updates the geometry of an +existing geofence if a geofence ID is included in the request. # Arguments - `collection_name`: The geofence collection to store the geofence in. - `geofence_id`: An identifier for the geofence. For example, ExampleGeofence-1. -- `geometry`: Contains the polygon details to specify the position of the geofence. +- `geometry`: Contains the polygon details to specify the position of the geofence. Each + geofence polygon can have a maximum of 1,000 vertices. """ put_geofence(CollectionName, GeofenceId, Geometry; aws_config::AbstractAWSConfig=global_aws_config()) = location("PUT", "/geofencing/v0/collections/$(CollectionName)/geofences/$(GeofenceId)", Dict{String, Any}("Geometry"=>Geometry); aws_config=aws_config) diff --git a/src/services/sagemaker.jl b/src/services/sagemaker.jl index c60af58d78..b7fdfc02bf 100644 --- a/src/services/sagemaker.jl +++ b/src/services/sagemaker.jl @@ -142,14 +142,15 @@ create_algorithm(AlgorithmName, TrainingSpecification, params::AbstractDict{Stri create_app(app_name, app_type, domain_id, user_profile_name) create_app(app_name, app_type, domain_id, user_profile_name, params::Dict{String,<:Any}) -Creates a running App for the specified UserProfile. Supported Apps are JupyterServer and +Creates a running app for the specified UserProfile. Supported apps are JupyterServer and KernelGateway. This operation is automatically invoked by Amazon SageMaker Studio upon access to the associated Domain, and when new kernel configurations are selected by the user. A user may have multiple Apps active simultaneously. # Arguments - `app_name`: The name of the app. -- `app_type`: The type of app. +- `app_type`: The type of app. Supported apps are JupyterServer and KernelGateway. + TensorBoard is not supported. - `domain_id`: The domain ID. - `user_profile_name`: The user profile name. @@ -210,31 +211,32 @@ create_artifact(ArtifactType, Source, params::AbstractDict{String, <:Any}; aws_c create_auto_mljob(auto_mljob_name, input_data_config, output_data_config, role_arn, params::Dict{String,<:Any}) Creates an Autopilot job. Find the best performing model after you run an Autopilot job by -calling . Deploy that model by following the steps described in Step 6.1: Deploy the Model -to Amazon SageMaker Hosting Services. For information about how to use Autopilot, see -Automate Model Development with Amazon SageMaker Autopilot. +calling . For information about how to use Autopilot, see Automate Model Development with +Amazon SageMaker Autopilot. # Arguments -- `auto_mljob_name`: Identifies an Autopilot job. Must be unique to your account and is - case-insensitive. -- `input_data_config`: Similar to InputDataConfig supported by Tuning. Format(s) supported: - CSV. Minimum of 500 rows. -- `output_data_config`: Similar to OutputDataConfig supported by Tuning. Format(s) - supported: CSV. +- `auto_mljob_name`: Identifies an Autopilot job. The name must be unique to your account + and is case-insensitive. +- `input_data_config`: An array of channel objects that describes the input data and its + location. Each channel is a named input source. Similar to InputDataConfig supported by . + Format(s) supported: CSV. Minimum of 500 rows. +- `output_data_config`: Provides information about encryption and the Amazon S3 output path + needed to store artifacts from an AutoML job. Format(s) supported: CSV. - `role_arn`: The ARN of the role that is used to access the data. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: -- `"AutoMLJobConfig"`: Contains CompletionCriteria and SecurityConfig. -- `"AutoMLJobObjective"`: Defines the objective of a an AutoML job. You provide a - AutoMLJobObjectiveMetricName and Autopilot infers whether to minimize or maximize it. If a - metric is not specified, the most commonly used ObjectiveMetric for problem type is - automaically selected. -- `"GenerateCandidateDefinitionsOnly"`: Generates possible candidates without training a - model. A candidate is a combination of data preprocessors, algorithms, and algorithm +- `"AutoMLJobConfig"`: Contains CompletionCriteria and SecurityConfig settings for the + AutoML job. +- `"AutoMLJobObjective"`: Defines the objective metric used to measure the predictive + quality of an AutoML job. You provide a AutoMLJobObjectiveMetricName and Autopilot infers + whether to minimize or maximize it. +- `"GenerateCandidateDefinitionsOnly"`: Generates possible candidates without training the + models. A candidate is a combination of data preprocessors, algorithms, and algorithm parameter settings. -- `"ProblemType"`: Defines the kind of preprocessing and algorithms intended for the - candidates. Options include: BinaryClassification, MulticlassClassification, and Regression. +- `"ProblemType"`: Defines the type of supervised learning available for the candidates. + Options include: BinaryClassification, MulticlassClassification, and Regression. For more + information, see Amazon SageMaker Autopilot problem types and algorithm support. - `"Tags"`: Each tag consists of a key and an optional value. Tag keys must be unique per resource. """ @@ -2376,10 +2378,10 @@ describe_artifact(ArtifactArn, params::AbstractDict{String, <:Any}; aws_config:: describe_auto_mljob(auto_mljob_name) describe_auto_mljob(auto_mljob_name, params::Dict{String,<:Any}) -Returns information about an Amazon SageMaker job. +Returns information about an Amazon SageMaker AutoML job. # Arguments -- `auto_mljob_name`: Request information about a job using that job's unique name. +- `auto_mljob_name`: Requests information about an AutoML job using its unique name. """ describe_auto_mljob(AutoMLJobName; aws_config::AbstractAWSConfig=global_aws_config()) = sagemaker("DescribeAutoMLJob", Dict{String, Any}("AutoMLJobName"=>AutoMLJobName); aws_config=aws_config) @@ -3221,20 +3223,20 @@ list_auto_mljobs(params::AbstractDict{String, <:Any}; aws_config::AbstractAWSCon list_candidates_for_auto_mljob(auto_mljob_name) list_candidates_for_auto_mljob(auto_mljob_name, params::Dict{String,<:Any}) -List the Candidates created for the job. +List the candidates created for the job. # Arguments -- `auto_mljob_name`: List the Candidates created for the job by providing the job's name. +- `auto_mljob_name`: List the candidates created for the job by providing the job's name. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: -- `"CandidateNameEquals"`: List the Candidates for the job and filter by candidate name. -- `"MaxResults"`: List the job's Candidates up to a specified limit. +- `"CandidateNameEquals"`: List the candidates for the job and filter by candidate name. +- `"MaxResults"`: List the job's candidates up to a specified limit. - `"NextToken"`: If the previous response was truncated, you receive this token. Use it in your next request to receive the next set of results. - `"SortBy"`: The parameter by which to sort the results. The default is Descending. - `"SortOrder"`: The sort order for the results. The default is Ascending. -- `"StatusEquals"`: List the Candidates for the job and filter by status. +- `"StatusEquals"`: List the candidates for the job and filter by status. """ list_candidates_for_auto_mljob(AutoMLJobName; aws_config::AbstractAWSConfig=global_aws_config()) = sagemaker("ListCandidatesForAutoMLJob", Dict{String, Any}("AutoMLJobName"=>AutoMLJobName); aws_config=aws_config) list_candidates_for_auto_mljob(AutoMLJobName, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = sagemaker("ListCandidatesForAutoMLJob", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("AutoMLJobName"=>AutoMLJobName), params)); aws_config=aws_config) diff --git a/src/services/wafv2.jl b/src/services/wafv2.jl index ea31c6a0b8..ec141e37ea 100644 --- a/src/services/wafv2.jl +++ b/src/services/wafv2.jl @@ -154,6 +154,13 @@ capacity requirements. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"CustomResponseBodies"`: A map of custom response keys and content bodies. When you + create a rule with a block action, you can send a custom response to the web request. You + define these for the rule group, and then use them in the rules that you define in the rule + group. For information about customizing web requests and responses, see Customizing web + requests and responses in AWS WAF in the AWS WAF Developer Guide. For information about + the limits on count and size for custom request and response settings, see AWS WAF quotas + in the AWS WAF Developer Guide. - `"Description"`: A description of the rule group that helps with identification. - `"Rules"`: The Rule statements used to identify the web requests that you want to allow, block, or count. Each rule includes one top-level statement that AWS WAF uses to identify @@ -192,6 +199,13 @@ an AWS AppSync GraphQL API. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"CustomResponseBodies"`: A map of custom response keys and content bodies. When you + create a rule with a block action, you can send a custom response to the web request. You + define these for the web ACL, and then use them in the rules and default actions that you + define in the web ACL. For information about customizing web requests and responses, see + Customizing web requests and responses in AWS WAF in the AWS WAF Developer Guide. For + information about the limits on count and size for custom request and response settings, + see AWS WAF quotas in the AWS WAF Developer Guide. - `"Description"`: A description of the Web ACL that helps with identification. - `"Rules"`: The Rule statements used to identify the web requests that you want to allow, block, or count. Each rule includes one top-level statement that AWS WAF uses to identify @@ -907,11 +921,7 @@ untag_resource(ResourceARN, TagKeys, params::AbstractDict{String, <:Any}; aws_co update_ipset(addresses, id, lock_token, name, scope) update_ipset(addresses, id, lock_token, name, scope, params::Dict{String,<:Any}) -Updates the specified IPSet. This operation completely replaces any IP address -specifications that you already have in the IP set with the ones that you provide to this -call. If you want to add to or modify the addresses that are already in the IP set, -retrieve those by calling GetIPSet, update them, and provide the complete updated array of -IP addresses to this call. +Updates the specified IPSet. # Arguments - `addresses`: Contains an array of strings that specify one or more IP addresses or blocks @@ -1016,6 +1026,13 @@ This allows others to reuse the rule group with confidence in its capacity requi # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"CustomResponseBodies"`: A map of custom response keys and content bodies. When you + create a rule with a block action, you can send a custom response to the web request. You + define these for the rule group, and then use them in the rules that you define in the rule + group. For information about customizing web requests and responses, see Customizing web + requests and responses in AWS WAF in the AWS WAF Developer Guide. For information about + the limits on count and size for custom request and response settings, see AWS WAF quotas + in the AWS WAF Developer Guide. - `"Description"`: A description of the rule group that helps with identification. - `"Rules"`: The Rule statements used to identify the web requests that you want to allow, block, or count. Each rule includes one top-level statement that AWS WAF uses to identify @@ -1062,6 +1079,13 @@ GraphQL API. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"CustomResponseBodies"`: A map of custom response keys and content bodies. When you + create a rule with a block action, you can send a custom response to the web request. You + define these for the web ACL, and then use them in the rules and default actions that you + define in the web ACL. For information about customizing web requests and responses, see + Customizing web requests and responses in AWS WAF in the AWS WAF Developer Guide. For + information about the limits on count and size for custom request and response settings, + see AWS WAF quotas in the AWS WAF Developer Guide. - `"Description"`: A description of the Web ACL that helps with identification. - `"Rules"`: The Rule statements used to identify the web requests that you want to allow, block, or count. Each rule includes one top-level statement that AWS WAF uses to identify