From aababa033865cdcebae549b879d9b1fe117e7b49 Mon Sep 17 00:00:00 2001 From: mattBrzezinski Date: Tue, 4 May 2021 06:10:47 +0000 Subject: [PATCH] AWS API Definitions Updated --- src/AWSServices.jl | 2 + src/services/chime.jl | 56 ++++++--- src/services/cloudfront.jl | 178 ++++++++++++++++++++++++++++ src/services/customer_profiles.jl | 81 +++++++++++-- src/services/ecs.jl | 50 +++++--- src/services/finspace.jl | 132 +++++++++++++++++++++ src/services/finspace_data.jl | 65 ++++++++++ src/services/forecast.jl | 22 ++++ src/services/macie2.jl | 4 +- src/services/marketplace_catalog.jl | 5 +- src/services/mturk.jl | 7 +- src/services/organizations.jl | 8 +- src/services/personalize.jl | 14 +-- src/services/securityhub.jl | 33 ++++-- 14 files changed, 591 insertions(+), 66 deletions(-) create mode 100644 src/services/finspace.jl create mode 100644 src/services/finspace_data.jl diff --git a/src/AWSServices.jl b/src/AWSServices.jl index 51e3f52880..94be55b581 100644 --- a/src/AWSServices.jl +++ b/src/AWSServices.jl @@ -101,6 +101,8 @@ const elasticsearch_service = AWS.RestJSONService("es", "2015-01-01") const emr = AWS.JSONService("elasticmapreduce", "2009-03-31", "1.1", "ElasticMapReduce") const emr_containers = AWS.RestJSONService("emr-containers", "2020-10-01") const eventbridge = AWS.JSONService("events", "2015-10-07", "1.1", "AWSEvents") +const finspace = AWS.RestJSONService("finspace", "2021-03-12") +const finspace_data = AWS.RestJSONService("finspace-api", "2020-07-13") const firehose = AWS.JSONService("firehose", "2015-08-04", "1.1", "Firehose_20150804") const fis = AWS.RestJSONService("fis", "2020-12-01") const fms = AWS.JSONService("fms", "2018-01-01", "1.1", "AWSFMS_20180101") diff --git a/src/services/chime.jl b/src/services/chime.jl index 542e4e4c17..fff976677f 100644 --- a/src/services/chime.jl +++ b/src/services/chime.jl @@ -87,6 +87,27 @@ Developer Guide. batch_create_attendee(Attendees, meetingId; aws_config::AbstractAWSConfig=global_aws_config()) = chime("POST", "/meetings/$(meetingId)/attendees?operation=batch-create", Dict{String, Any}("Attendees"=>Attendees); aws_config=aws_config) batch_create_attendee(Attendees, meetingId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = chime("POST", "/meetings/$(meetingId)/attendees?operation=batch-create", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Attendees"=>Attendees), params)); aws_config=aws_config) +""" + batch_create_channel_membership(member_arns, channel_arn) + batch_create_channel_membership(member_arns, channel_arn, params::Dict{String,<:Any}) + +Adds a specified number of users to a channel. + +# Arguments +- `member_arns`: The ARNs of the members you want to add to the channel. +- `channel_arn`: The ARN of the channel to which you're adding users. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"Type"`: The membership type of a user, DEFAULT or HIDDEN. Default members are always + returned as part of ListChannelMemberships. Hidden members are only returned if the type + filter in ListChannelMemberships equals HIDDEN. Otherwise hidden members are not returned. + This is only supported by moderators. +- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call. +""" +batch_create_channel_membership(MemberArns, channelArn; aws_config::AbstractAWSConfig=global_aws_config()) = chime("POST", "/channels/$(channelArn)/memberships?operation=batch-create", Dict{String, Any}("MemberArns"=>MemberArns); aws_config=aws_config) +batch_create_channel_membership(MemberArns, channelArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = chime("POST", "/channels/$(channelArn)/memberships?operation=batch-create", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("MemberArns"=>MemberArns), params)); aws_config=aws_config) + """ batch_create_room_membership(membership_item_list, account_id, room_id) batch_create_room_membership(membership_item_list, account_id, room_id, params::Dict{String,<:Any}) @@ -585,8 +606,9 @@ Creates an outbound call to a phone number from the phone number specified in th and it invokes the endpoint of the specified sipMediaApplicationId. # Arguments -- `from_phone_number`: The phone number that a user calls from. -- `to_phone_number`: The phone number that the user dials in order to connect to a meeting. +- `from_phone_number`: The phone number that a user calls from. This is a phone number in + your Amazon Chime phone number inventory. +- `to_phone_number`: The phone number that the service should call. - `sip_media_application_id`: The ID of the SIP media application. """ @@ -691,7 +713,7 @@ account. You can use the BatchSuspendUser action to dodo. For EnterpriseLWA and EnterpriseAD accounts, you must release the claimed domains for your Amazon Chime account before deletion. As soon as you release the domain, all users under that account are suspended. Deleted accounts appear in your Disabled accounts list for 90 days. To restore -deleted account from your Disabled accounts list, you must contact AWS Support. After 90 +deleted account from your Disabled accounts list, you must contact AWS Support. After 90 days, deleted accounts are permanently removed from your Disabled accounts list. # Arguments @@ -758,10 +780,10 @@ delete_app_instance_user(appInstanceUserArn, params::AbstractDict{String}; aws_c delete_attendee(attendee_id, meeting_id) delete_attendee(attendee_id, meeting_id, params::Dict{String,<:Any}) - Deletes an attendee from the specified Amazon Chime SDK meeting and deletes their -JoinToken . Attendees are automatically deleted when a Amazon Chime SDK meeting is deleted. +Deletes an attendee from the specified Amazon Chime SDK meeting and deletes their +JoinToken. Attendees are automatically deleted when a Amazon Chime SDK meeting is deleted. For more information about the Amazon Chime SDK, see Using the Amazon Chime SDK in the -Amazon Chime Developer Guide . +Amazon Chime Developer Guide. # Arguments - `attendee_id`: The Amazon Chime SDK attendee ID. @@ -882,10 +904,10 @@ delete_events_configuration(accountId, botId, params::AbstractDict{String}; aws_ delete_meeting(meeting_id) delete_meeting(meeting_id, params::Dict{String,<:Any}) -Deletes the specified Amazon Chime SDK meeting. When a meeting is deleted, its attendees -are also deleted, clients connected to the meeting are disconnected, and clients can no -longer join the meeting. For more information about the Amazon Chime SDK, see Using the -Amazon Chime SDK in the Amazon Chime Developer Guide. +Deletes the specified Amazon Chime SDK meeting. The operation deletes all attendees, +disconnects all clients, and prevents new clients from joining the meeting. For more +information about the Amazon Chime SDK, see Using the Amazon Chime SDK in the Amazon Chime +Developer Guide. # Arguments - `meeting_id`: The Amazon Chime SDK meeting ID. @@ -1011,8 +1033,8 @@ delete_voice_connector_emergency_calling_configuration(voiceConnectorId, params: delete_voice_connector_group(voice_connector_group_id) delete_voice_connector_group(voice_connector_group_id, params::Dict{String,<:Any}) - Deletes the specified Amazon Chime Voice Connector group. Any VoiceConnectorItems and -phone numbers associated with the group must be removed before it can be deleted. +Deletes the specified Amazon Chime Voice Connector group. Any VoiceConnectorItems and phone +numbers associated with the group must be removed before it can be deleted. # Arguments - `voice_connector_group_id`: The Amazon Chime Voice Connector group ID. @@ -1761,7 +1783,7 @@ invite_users(UserEmailList, accountId, params::AbstractDict{String}; aws_config: Lists the Amazon Chime accounts under the administrator's AWS account. You can filter accounts by account name prefix. To find out which Amazon Chime account a user belongs to, -toucan filter by the user's email address, which returns one account result. +you can filter by the user's email address, which returns one account result. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: @@ -1994,8 +2016,8 @@ list_channel_moderators(channelArn, params::AbstractDict{String}; aws_config::Ab list_channels(app-instance-arn, params::Dict{String,<:Any}) Lists all Channels created under a single Chime App as a paginated list. You can specify -filters to narrow results. Functionality & restrictions Use privacy = PUBLIC to -retrieve all public channels in the account Only an AppInstanceAdmin can set privacy = +filters to narrow results. Functionality & restrictions Use privacy = PUBLIC to +retrieve all public channels in the account. Only an AppInstanceAdmin can set privacy = PRIVATE to list the private channels in an account. The x-amz-chime-bearer request header is mandatory. Use the AppInstanceUserArn of the user that makes the API call as the value in the header. @@ -2008,7 +2030,7 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys - `"max-results"`: The maximum number of channels that you want to return. - `"next-token"`: The token passed by previous API calls until all requested channels are returned. -- `"privacy"`: The privacy setting. PUBLIC retrieves all the public channels. PRIVATE +- `"privacy"`: The privacy setting. PUBLIC retrieves all the public channels. PRIVATE retrieves private channels. Only an AppInstanceAdmin can retrieve private channels. - `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call. """ @@ -3048,7 +3070,7 @@ Amazon Chime Voice Connector priority ranking. # Arguments - `name`: The name of the Amazon Chime Voice Connector group. -- `voice_connector_items`: The VoiceConnectorItems to associate with the group. +- `voice_connector_items`: The VoiceConnectorItems to associate with the group. - `voice_connector_group_id`: The Amazon Chime Voice Connector group ID. """ diff --git a/src/services/cloudfront.jl b/src/services/cloudfront.jl index cce437b487..014fa5b4b8 100644 --- a/src/services/cloudfront.jl +++ b/src/services/cloudfront.jl @@ -108,6 +108,31 @@ Create a field-level encryption profile. create_field_level_encryption_profile2020_05_31(FieldLevelEncryptionProfileConfig; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("POST", "/2020-05-31/field-level-encryption-profile", Dict{String, Any}("FieldLevelEncryptionProfileConfig"=>FieldLevelEncryptionProfileConfig); aws_config=aws_config) create_field_level_encryption_profile2020_05_31(FieldLevelEncryptionProfileConfig, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("POST", "/2020-05-31/field-level-encryption-profile", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("FieldLevelEncryptionProfileConfig"=>FieldLevelEncryptionProfileConfig), params)); aws_config=aws_config) +""" + create_function2020_05_31(function_code, function_config, name) + create_function2020_05_31(function_code, function_config, name, params::Dict{String,<:Any}) + +Creates a CloudFront function. To create a function, you provide the function code and some +configuration information about the function. The response contains an Amazon Resource Name +(ARN) that uniquely identifies the function. When you create a function, it’s in the +DEVELOPMENT stage. In this stage, you can test the function with TestFunction, and update +it with UpdateFunction. When you’re ready to use your function with a CloudFront +distribution, use PublishFunction to copy the function from the DEVELOPMENT stage to LIVE. +When it’s live, you can attach the function to a distribution’s cache behavior, using +the function’s ARN. + +# Arguments +- `function_code`: The function code. For more information about writing a CloudFront + function, see Writing function code for CloudFront Functions in the Amazon CloudFront + Developer Guide. +- `function_config`: Configuration information about the function, including an optional + comment and the function’s runtime. +- `name`: A name to identify the function. + +""" +create_function2020_05_31(FunctionCode, FunctionConfig, Name; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("POST", "/2020-05-31/function", Dict{String, Any}("FunctionCode"=>FunctionCode, "FunctionConfig"=>FunctionConfig, "Name"=>Name); aws_config=aws_config) +create_function2020_05_31(FunctionCode, FunctionConfig, Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("POST", "/2020-05-31/function", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("FunctionCode"=>FunctionCode, "FunctionConfig"=>FunctionConfig, "Name"=>Name), params)); aws_config=aws_config) + """ create_invalidation2020_05_31(distribution_id, invalidation_batch) create_invalidation2020_05_31(distribution_id, invalidation_batch, params::Dict{String,<:Any}) @@ -350,6 +375,25 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys delete_field_level_encryption_profile2020_05_31(Id; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("DELETE", "/2020-05-31/field-level-encryption-profile/$(Id)"; aws_config=aws_config) delete_field_level_encryption_profile2020_05_31(Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("DELETE", "/2020-05-31/field-level-encryption-profile/$(Id)", params; aws_config=aws_config) +""" + delete_function2020_05_31(if-_match, name) + delete_function2020_05_31(if-_match, name, params::Dict{String,<:Any}) + +Deletes a CloudFront function. You cannot delete a function if it’s associated with a +cache behavior. First, update your distributions to remove the function association from +all cache behaviors, then delete the function. To delete a function, you must provide the +function’s name and version (ETag value). To get these values, you can use ListFunctions +and DescribeFunction. + +# Arguments +- `if-_match`: The current version (ETag value) of the function that you are deleting, + which you can get using DescribeFunction. +- `name`: The name of the function that you are deleting. + +""" +delete_function2020_05_31(If_Match, Name; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("DELETE", "/2020-05-31/function/$(Name)", Dict{String, Any}("headers"=>Dict{String, Any}("If-Match"=>If_Match)); aws_config=aws_config) +delete_function2020_05_31(If_Match, Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("DELETE", "/2020-05-31/function/$(Name)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("If-Match"=>If_Match)), params)); aws_config=aws_config) + """ delete_key_group2020_05_31(id) delete_key_group2020_05_31(id, params::Dict{String,<:Any}) @@ -480,6 +524,25 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys delete_streaming_distribution2020_05_31(Id; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("DELETE", "/2020-05-31/streaming-distribution/$(Id)"; aws_config=aws_config) delete_streaming_distribution2020_05_31(Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("DELETE", "/2020-05-31/streaming-distribution/$(Id)", params; aws_config=aws_config) +""" + describe_function2020_05_31(name) + describe_function2020_05_31(name, params::Dict{String,<:Any}) + +Gets configuration information and metadata about a CloudFront function, but not the +function’s code. To get a function’s code, use GetFunction. To get configuration +information and metadata about a function, you must provide the function’s name and +stage. To get these values, you can use ListFunctions. + +# Arguments +- `name`: The name of the function that you are getting information about. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"Stage"`: The function’s stage, either DEVELOPMENT or LIVE. +""" +describe_function2020_05_31(Name; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("GET", "/2020-05-31/function/$(Name)/describe"; aws_config=aws_config) +describe_function2020_05_31(Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("GET", "/2020-05-31/function/$(Name)/describe", params; aws_config=aws_config) + """ get_cache_policy2020_05_31(id) get_cache_policy2020_05_31(id, params::Dict{String,<:Any}) @@ -627,6 +690,24 @@ Get the field-level encryption profile configuration information. get_field_level_encryption_profile_config2020_05_31(Id; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("GET", "/2020-05-31/field-level-encryption-profile/$(Id)/config"; aws_config=aws_config) get_field_level_encryption_profile_config2020_05_31(Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("GET", "/2020-05-31/field-level-encryption-profile/$(Id)/config", params; aws_config=aws_config) +""" + get_function2020_05_31(name) + get_function2020_05_31(name, params::Dict{String,<:Any}) + +Gets the code of a CloudFront function. To get configuration information and metadata about +a function, use DescribeFunction. To get a function’s code, you must provide the +function’s name and stage. To get these values, you can use ListFunctions. + +# Arguments +- `name`: The name of the function whose code you are getting. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"Stage"`: The function’s stage, either DEVELOPMENT or LIVE. +""" +get_function2020_05_31(Name; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("GET", "/2020-05-31/function/$(Name)"; aws_config=aws_config) +get_function2020_05_31(Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("GET", "/2020-05-31/function/$(Name)", params; aws_config=aws_config) + """ get_invalidation2020_05_31(distribution_id, id) get_invalidation2020_05_31(distribution_id, id, params::Dict{String,<:Any}) @@ -1032,6 +1113,31 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys list_field_level_encryption_profiles2020_05_31(; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("GET", "/2020-05-31/field-level-encryption-profile"; aws_config=aws_config) list_field_level_encryption_profiles2020_05_31(params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("GET", "/2020-05-31/field-level-encryption-profile", params; aws_config=aws_config) +""" + list_functions2020_05_31() + list_functions2020_05_31(params::Dict{String,<:Any}) + +Gets a list of all CloudFront functions in your AWS account. You can optionally apply a +filter to return only the functions that are in the specified stage, either DEVELOPMENT or +LIVE. You can optionally specify the maximum number of items to receive in the response. If +the total number of items in the list exceeds the maximum that you specify, or the default +maximum, the response is paginated. To get the next page of items, send a subsequent +request that specifies the NextMarker value from the current response as the Marker value +in the subsequent request. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"Marker"`: Use this field when paginating results to indicate where to begin in your + list of functions. The response includes functions in the list that occur after the marker. + To get the next page of the list, set this field’s value to the value of NextMarker from + the current page’s response. +- `"MaxItems"`: The maximum number of functions that you want in the response. +- `"Stage"`: An optional filter to return only the functions that are in the specified + stage, either DEVELOPMENT or LIVE. +""" +list_functions2020_05_31(; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("GET", "/2020-05-31/function"; aws_config=aws_config) +list_functions2020_05_31(params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("GET", "/2020-05-31/function", params; aws_config=aws_config) + """ list_invalidations2020_05_31(distribution_id) list_invalidations2020_05_31(distribution_id, params::Dict{String,<:Any}) @@ -1168,6 +1274,27 @@ List tags for a CloudFront resource. list_tags_for_resource2020_05_31(Resource; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("GET", "/2020-05-31/tagging", Dict{String, Any}("Resource"=>Resource); aws_config=aws_config) list_tags_for_resource2020_05_31(Resource, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("GET", "/2020-05-31/tagging", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Resource"=>Resource), params)); aws_config=aws_config) +""" + publish_function2020_05_31(if-_match, name) + publish_function2020_05_31(if-_match, name, params::Dict{String,<:Any}) + +Publishes a CloudFront function by copying the function code from the DEVELOPMENT stage to +LIVE. This automatically updates all cache behaviors that are using this function to use +the newly published copy in the LIVE stage. When a function is published to the LIVE stage, +you can attach the function to a distribution’s cache behavior, using the function’s +Amazon Resource Name (ARN). To publish a function, you must provide the function’s name +and version (ETag value). To get these values, you can use ListFunctions and +DescribeFunction. + +# Arguments +- `if-_match`: The current version (ETag value) of the function that you are publishing, + which you can get using DescribeFunction. +- `name`: The name of the function that you are publishing. + +""" +publish_function2020_05_31(If_Match, Name; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("POST", "/2020-05-31/function/$(Name)/publish", Dict{String, Any}("headers"=>Dict{String, Any}("If-Match"=>If_Match)); aws_config=aws_config) +publish_function2020_05_31(If_Match, Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("POST", "/2020-05-31/function/$(Name)/publish", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("If-Match"=>If_Match)), params)); aws_config=aws_config) + """ tag_resource2020_05_31(resource, tags) tag_resource2020_05_31(resource, tags, params::Dict{String,<:Any}) @@ -1182,6 +1309,35 @@ Add tags to a CloudFront resource. tag_resource2020_05_31(Resource, Tags; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("POST", "/2020-05-31/tagging?Operation=Tag", Dict{String, Any}("Resource"=>Resource, "Tags"=>Tags); aws_config=aws_config) tag_resource2020_05_31(Resource, Tags, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("POST", "/2020-05-31/tagging?Operation=Tag", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Resource"=>Resource, "Tags"=>Tags), params)); aws_config=aws_config) +""" + test_function2020_05_31(event_object, if-_match, name) + test_function2020_05_31(event_object, if-_match, name, params::Dict{String,<:Any}) + +Tests a CloudFront function. To test a function, you provide an event object that +represents an HTTP request or response that your CloudFront distribution could receive in +production. CloudFront runs the function, passing it the event object that you provided, +and returns the function’s result (the modified event object) in the response. The +response also contains function logs and error messages, if any exist. For more information +about testing functions, see Testing functions in the Amazon CloudFront Developer Guide. To +test a function, you provide the function’s name and version (ETag value) along with the +event object. To get the function’s name and version, you can use ListFunctions and +DescribeFunction. + +# Arguments +- `event_object`: The event object to test the function with. For more information about + the structure of the event object, see Testing functions in the Amazon CloudFront Developer + Guide. +- `if-_match`: The current version (ETag value) of the function that you are testing, which + you can get using DescribeFunction. +- `name`: The name of the function that you are testing. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"Stage"`: The stage of the function that you are testing, either DEVELOPMENT or LIVE. +""" +test_function2020_05_31(EventObject, If_Match, Name; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("POST", "/2020-05-31/function/$(Name)/test", Dict{String, Any}("EventObject"=>EventObject, "headers"=>Dict{String, Any}("If-Match"=>If_Match)); aws_config=aws_config) +test_function2020_05_31(EventObject, If_Match, Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("POST", "/2020-05-31/function/$(Name)/test", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("EventObject"=>EventObject, "headers"=>Dict{String, Any}("If-Match"=>If_Match)), params)); aws_config=aws_config) + """ untag_resource2020_05_31(resource, tag_keys) untag_resource2020_05_31(resource, tag_keys, params::Dict{String,<:Any}) @@ -1328,6 +1484,28 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys update_field_level_encryption_profile2020_05_31(FieldLevelEncryptionProfileConfig, Id; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("PUT", "/2020-05-31/field-level-encryption-profile/$(Id)/config", Dict{String, Any}("FieldLevelEncryptionProfileConfig"=>FieldLevelEncryptionProfileConfig); aws_config=aws_config) update_field_level_encryption_profile2020_05_31(FieldLevelEncryptionProfileConfig, Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("PUT", "/2020-05-31/field-level-encryption-profile/$(Id)/config", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("FieldLevelEncryptionProfileConfig"=>FieldLevelEncryptionProfileConfig), params)); aws_config=aws_config) +""" + update_function2020_05_31(function_code, function_config, if-_match, name) + update_function2020_05_31(function_code, function_config, if-_match, name, params::Dict{String,<:Any}) + +Updates a CloudFront function. You can update a function’s code or the comment that +describes the function. You cannot update a function’s name. To update a function, you +provide the function’s name and version (ETag value) along with the updated function +code. To get the name and version, you can use ListFunctions and DescribeFunction. + +# Arguments +- `function_code`: The function code. For more information about writing a CloudFront + function, see Writing function code for CloudFront Functions in the Amazon CloudFront + Developer Guide. +- `function_config`: Configuration information about the function. +- `if-_match`: The current version (ETag value) of the function that you are updating, + which you can get using DescribeFunction. +- `name`: The name of the function that you are updating. + +""" +update_function2020_05_31(FunctionCode, FunctionConfig, If_Match, Name; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("PUT", "/2020-05-31/function/$(Name)", Dict{String, Any}("FunctionCode"=>FunctionCode, "FunctionConfig"=>FunctionConfig, "headers"=>Dict{String, Any}("If-Match"=>If_Match)); aws_config=aws_config) +update_function2020_05_31(FunctionCode, FunctionConfig, If_Match, Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = cloudfront("PUT", "/2020-05-31/function/$(Name)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("FunctionCode"=>FunctionCode, "FunctionConfig"=>FunctionConfig, "headers"=>Dict{String, Any}("If-Match"=>If_Match)), params)); aws_config=aws_config) + """ update_key_group2020_05_31(id, key_group_config) update_key_group2020_05_31(id, key_group_config, params::Dict{String,<:Any}) diff --git a/src/services/customer_profiles.jl b/src/services/customer_profiles.jl index 81c278cc47..655bcb99d4 100644 --- a/src/services/customer_profiles.jl +++ b/src/services/customer_profiles.jl @@ -46,6 +46,8 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys - `"DefaultEncryptionKey"`: The default encryption key, which is an AWS managed key, is used when no specific type of encryption key is specified. It is used to encrypt all data before it is placed in permanent or semi-permanent storage. +- `"Matching"`: The process of matching duplicate profiles. This process runs every + Saturday at 12AM. - `"Tags"`: The tags used to organize, track, or control access for this resource. """ create_domain(DefaultExpirationDays, DomainName; aws_config::AbstractAWSConfig=global_aws_config()) = customer_profiles("POST", "/domains/$(DomainName)", Dict{String, Any}("DefaultExpirationDays"=>DefaultExpirationDays); aws_config=aws_config) @@ -64,7 +66,8 @@ customer profile in a domain. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: - `"AccountNumber"`: A unique account number that you have given to the customer. -- `"AdditionalInformation"`: Any additional information relevant to the customer's profile. +- `"AdditionalInformation"`: Any additional information relevant to the customer’s + profile. - `"Address"`: A generic address associated with the customer that is not mailing, shipping, or billing. - `"Attributes"`: A key value pair of attributes of a customer profile. @@ -73,7 +76,7 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys - `"BusinessEmailAddress"`: The customer’s business email address. - `"BusinessName"`: The name of the customer’s business. - `"BusinessPhoneNumber"`: The customer’s business phone number. -- `"EmailAddress"`: The customer's email address, which has not been specified as a +- `"EmailAddress"`: The customer’s email address, which has not been specified as a personal or business address. - `"FirstName"`: The customer’s first name. - `"Gender"`: The gender with which the customer identifies. @@ -84,7 +87,7 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys - `"MobilePhoneNumber"`: The customer’s mobile phone number. - `"PartyType"`: The type of profile used to describe the customer. - `"PersonalEmailAddress"`: The customer’s personal email address. -- `"PhoneNumber"`: The customer's phone number, which has not been specified as a mobile, +- `"PhoneNumber"`: The customer’s phone number, which has not been specified as a mobile, home, or business number. - `"ShippingAddress"`: The customer’s shipping address. """ @@ -190,7 +193,7 @@ delete_profile_object_type(DomainName, ObjectTypeName, params::AbstractDict{Stri Returns information about a specific domain. # Arguments -- `domain_name`: A unique name for the domain. +- `domain_name`: The unique name of the domain. """ get_domain(DomainName; aws_config::AbstractAWSConfig=global_aws_config()) = customer_profiles("GET", "/domains/$(DomainName)"; aws_config=aws_config) @@ -210,6 +213,31 @@ Returns an integration for a domain. get_integration(DomainName, Uri; aws_config::AbstractAWSConfig=global_aws_config()) = customer_profiles("POST", "/domains/$(DomainName)/integrations", Dict{String, Any}("Uri"=>Uri); aws_config=aws_config) get_integration(DomainName, Uri, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = customer_profiles("POST", "/domains/$(DomainName)/integrations", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Uri"=>Uri), params)); aws_config=aws_config) +""" + get_matches(domain_name) + get_matches(domain_name, params::Dict{String,<:Any}) + +This API is in preview release for Amazon Connect and subject to change. Before calling +this API, use CreateDomain or UpdateDomain to enable identity resolution: set Matching to +true. GetMatches returns potentially matching profiles, based on the results of the latest +run of a machine learning process. Amazon Connect runs a batch process every Saturday at +12AM UTC to identify matching profiles. The results are returned up to seven days after the +Saturday run. Amazon Connect uses the following profile attributes to identify matches: +PhoneNumber HomePhoneNumber BusinessPhoneNumber MobilePhoneNumber EmailAddress +PersonalEmailAddress BusinessEmailAddress FullName BusinessName + +# Arguments +- `domain_name`: The unique name of the domain. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"max-results"`: The maximum number of results to return per page. +- `"next-token"`: The token for the next set of results. Use the value returned in the + previous response in the next request to retrieve the next set of results. +""" +get_matches(DomainName; aws_config::AbstractAWSConfig=global_aws_config()) = customer_profiles("GET", "/domains/$(DomainName)/matches"; aws_config=aws_config) +get_matches(DomainName, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = customer_profiles("GET", "/domains/$(DomainName)/matches", params; aws_config=aws_config) + """ get_profile_object_type(domain_name, object_type_name) get_profile_object_type(domain_name, object_type_name, params::Dict{String,<:Any}) @@ -352,6 +380,38 @@ Customer Profiles, domains, profile object types, and integrations can be tagged list_tags_for_resource(resourceArn; aws_config::AbstractAWSConfig=global_aws_config()) = customer_profiles("GET", "/tags/$(resourceArn)"; aws_config=aws_config) list_tags_for_resource(resourceArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = customer_profiles("GET", "/tags/$(resourceArn)", params; aws_config=aws_config) +""" + merge_profiles(domain_name, main_profile_id, profile_ids_to_be_merged) + merge_profiles(domain_name, main_profile_id, profile_ids_to_be_merged, params::Dict{String,<:Any}) + +This API is in preview release for Amazon Connect and subject to change. Runs an AWS Lambda +job that does the following: All the profileKeys in the ProfileToBeMerged will be moved +to the main profile. All the objects in the ProfileToBeMerged will be moved to the main +profile. All the ProfileToBeMerged will be deleted at the end. All the profileKeys in +the ProfileIdsToBeMerged will be moved to the main profile. Standard fields are merged as +follows: Fields are always \"union\"-ed if there are no conflicts in standard fields or +attributeKeys. When there are conflicting fields: If no SourceProfileIds entry is +specified, the main Profile value is always taken. If a SourceProfileIds entry is +specified, the specified profileId is always taken, even if it is a NULL value. You +can use MergeProfiles together with GetMatches, which returns potentially matching +profiles, or use it with the results of another matching system. After profiles have been +merged, they cannot be separated (unmerged). + +# Arguments +- `domain_name`: The unique name of the domain. +- `main_profile_id`: The identifier of the profile to be taken. +- `profile_ids_to_be_merged`: The identifier of the profile to be merged into MainProfileId. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"FieldSourceProfileIds"`: The identifiers of the fields in the profile that has the + information you want to apply to the merge. For example, say you want to merge EmailAddress + from Profile1 into MainProfile. This would be the identifier of the EmailAddress field in + Profile1. +""" +merge_profiles(DomainName, MainProfileId, ProfileIdsToBeMerged; aws_config::AbstractAWSConfig=global_aws_config()) = customer_profiles("POST", "/domains/$(DomainName)/profiles/objects/merge", Dict{String, Any}("MainProfileId"=>MainProfileId, "ProfileIdsToBeMerged"=>ProfileIdsToBeMerged); aws_config=aws_config) +merge_profiles(DomainName, MainProfileId, ProfileIdsToBeMerged, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = customer_profiles("POST", "/domains/$(DomainName)/profiles/objects/merge", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("MainProfileId"=>MainProfileId, "ProfileIdsToBeMerged"=>ProfileIdsToBeMerged), params)); aws_config=aws_config) + """ put_integration(domain_name, object_type_name) put_integration(domain_name, object_type_name, params::Dict{String,<:Any}) @@ -490,10 +550,10 @@ untag_resource(resourceArn, tagKeys, params::AbstractDict{String}; aws_config::A update_domain(domain_name, params::Dict{String,<:Any}) Updates the properties of a domain, including creating or selecting a dead letter queue or -an encryption key. Once a domain is created, the name can’t be changed. +an encryption key. After a domain is created, the name can’t be changed. # Arguments -- `domain_name`: The unique name for the domain. +- `domain_name`: The unique name of the domain. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: @@ -508,6 +568,8 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys string, it will clear any existing value. - `"DefaultExpirationDays"`: The default number of days until the data within the domain expires. +- `"Matching"`: The process of matching duplicate profiles. This process runs every + Saturday at 12AM. - `"Tags"`: The tags used to organize, track, or control access for this resource. """ update_domain(DomainName; aws_config::AbstractAWSConfig=global_aws_config()) = customer_profiles("PUT", "/domains/$(DomainName)"; aws_config=aws_config) @@ -529,7 +591,8 @@ already there will be kept. # Optional Parameters Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: - `"AccountNumber"`: A unique account number that you have given to the customer. -- `"AdditionalInformation"`: Any additional information relevant to the customer's profile. +- `"AdditionalInformation"`: Any additional information relevant to the customer’s + profile. - `"Address"`: A generic address associated with the customer that is not mailing, shipping, or billing. - `"Attributes"`: A key value pair of attributes of a customer profile. @@ -538,7 +601,7 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys - `"BusinessEmailAddress"`: The customer’s business email address. - `"BusinessName"`: The name of the customer’s business. - `"BusinessPhoneNumber"`: The customer’s business phone number. -- `"EmailAddress"`: The customer's email address, which has not been specified as a +- `"EmailAddress"`: The customer’s email address, which has not been specified as a personal or business address. - `"FirstName"`: The customer’s first name. - `"Gender"`: The gender with which the customer identifies. @@ -549,7 +612,7 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys - `"MobilePhoneNumber"`: The customer’s mobile phone number. - `"PartyType"`: The type of profile used to describe the customer. - `"PersonalEmailAddress"`: The customer’s personal email address. -- `"PhoneNumber"`: The customer's phone number, which has not been specified as a mobile, +- `"PhoneNumber"`: The customer’s phone number, which has not been specified as a mobile, home, or business number. - `"ShippingAddress"`: The customer’s shipping address. """ diff --git a/src/services/ecs.jl b/src/services/ecs.jl index ca5cd16bbe..6172ccb795 100644 --- a/src/services/ecs.jl +++ b/src/services/ecs.jl @@ -187,7 +187,8 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys run your service. If you do not specify a cluster, the default cluster is assumed. - `"deploymentConfiguration"`: Optional deployment parameters that control how many tasks run during the deployment and the ordering of stopping and starting tasks. -- `"deploymentController"`: The deployment controller to use for the service. +- `"deploymentController"`: The deployment controller to use for the service. If no + deployment controller is specified, the default value of ECS is used. - `"desiredCount"`: The number of instantiations of the specified task definition to place and keep running on your cluster. This is required if schedulingStrategy is REPLICA or is not specified. If schedulingStrategy is DAEMON then this is not required. @@ -293,10 +294,9 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys tasks, a task placement strategy, or use Service Auto Scaling policies. Tasks using the Fargate launch type or the CODE_DEPLOY or EXTERNAL deployment controller types don't support the DAEMON scheduling strategy. -- `"serviceRegistries"`: The details of the service discovery registries to assign to this - service. For more information, see Service discovery. Service discovery is supported for - Fargate tasks if you are using platform version v1.1.0 or later. For more information, see - AWS Fargate platform versions. +- `"serviceRegistries"`: The details of the service discovery registry to associate with + this service. For more information, see Service discovery. Each service may be associated + with one service registry. Multiple service registries per service isn't supported. - `"tags"`: The metadata that you apply to the service to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. When a service is deleted, the tags are deleted as well. The following basic restrictions apply to @@ -362,11 +362,12 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys - `"loadBalancers"`: A load balancer object representing the load balancer to use with the task set. The supported load balancer types are either an Application Load Balancer or a Network Load Balancer. -- `"networkConfiguration"`: +- `"networkConfiguration"`: An object representing the network configuration for a task set. - `"platformVersion"`: The platform version that the tasks in the task set should use. A platform version is specified only for tasks using the Fargate launch type. If one isn't specified, the LATEST platform version is used by default. -- `"scale"`: +- `"scale"`: A floating-point percentage of the desired number of tasks to place and keep + running in the task set. - `"serviceRegistries"`: The details of the service discovery registries to assign to this task set. For more information, see Service Discovery. - `"tags"`: The metadata that you apply to the task set to help you categorize and organize @@ -830,7 +831,8 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys items in a list and not for other programmatic purposes. - `"principalArn"`: The ARN of the principal, which can be an IAM user, IAM role, or the root user. If this field is omitted, the account settings are listed only for the - authenticated user. + authenticated user. Federated users assume the account setting of the root user and can't + have explicit account settings set for them. - `"value"`: The value of the account settings with which to filter results. You must also specify an account setting name to use this parameter. """ @@ -1142,7 +1144,8 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys root user. If you specify the root user, it modifies the account setting for all IAM users, IAM roles, and the root user of the account unless an IAM user or role explicitly overrides these settings. If this field is omitted, the setting is changed only for the authenticated - user. + user. Federated users assume the account setting of the root user and can't have explicit + account settings set for them. """ put_account_setting(name, value; aws_config::AbstractAWSConfig=global_aws_config()) = ecs("PutAccountSetting", Dict{String, Any}("name"=>name, "value"=>value); aws_config=aws_config) put_account_setting(name, value, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = ecs("PutAccountSetting", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("name"=>name, "value"=>value), params)); aws_config=aws_config) @@ -1324,6 +1327,11 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) 4096 (4 vCPU) - Available memory values: Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) +- `"ephemeralStorage"`: The amount of ephemeral storage to allocate for the task. This + parameter is used to expand the total amount of ephemeral storage available, beyond the + default amount, for tasks hosted on AWS Fargate. For more information, see Fargate task + storage in the Amazon ECS User Guide for AWS Fargate. This parameter is only supported for + tasks hosted on AWS Fargate using platform version 1.4.0 or later. - `"executionRoleArn"`: The Amazon Resource Name (ARN) of the task execution role that grants the Amazon ECS container agent permission to make AWS API calls on your behalf. The task execution IAM role is required depending on the requirements of your task. For more @@ -1399,7 +1407,13 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys - `"placementConstraints"`: An array of placement constraint objects to use for the task. You can specify a maximum of 10 constraints per task (this limit includes constraints in the task definition and those specified at runtime). -- `"proxyConfiguration"`: +- `"proxyConfiguration"`: The configuration details for the App Mesh proxy. For tasks + hosted on Amazon EC2 instances, the container instances require at least version 1.26.0 of + the container agent and at least version 1.26.0-1 of the ecs-init package to enable a proxy + configuration. If your container instances are launched from the Amazon ECS-optimized AMI + version 20190301 or later, then they contain the required versions of the container agent + and ecs-init. For more information, see Amazon ECS-optimized AMI versions in the Amazon + Elastic Container Service Developer Guide. - `"requiresCompatibilities"`: The task launch type that Amazon ECS should validate the task definition against. A client exception is returned if the task definition doesn't validate against the compatibilities specified. If no value is specified, the parameter is @@ -1781,10 +1795,14 @@ update_cluster_settings(cluster, settings, params::AbstractDict{String}; aws_con Updates the Amazon ECS container agent on a specified container instance. Updating the Amazon ECS container agent does not interrupt running tasks or services on the container instance. The process for updating the agent differs depending on whether your container -instance was launched with the Amazon ECS-optimized AMI or another operating system. -UpdateContainerAgent requires the Amazon ECS-optimized AMI or Amazon Linux with the +instance was launched with the Amazon ECS-optimized AMI or another operating system. The +UpdateContainerAgent API isn't supported for container instances using the Amazon +ECS-optimized Amazon Linux 2 (arm64) AMI. To update the container agent, you can update the +ecs-init package which will update the agent. For more information, see Updating the Amazon +ECS container agent in the Amazon Elastic Container Service Developer Guide. The +UpdateContainerAgent API requires an Amazon ECS-optimized AMI or Amazon Linux AMI with the ecs-init service installed and running. For help updating the Amazon ECS container agent on -other operating systems, see Manually Updating the Amazon ECS Container Agent in the Amazon +other operating systems, see Manually updating the Amazon ECS container agent in the Amazon Elastic Container Service Developer Guide. # Arguments @@ -1964,7 +1982,8 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys seconds. During that time, the Amazon ECS service scheduler ignores the Elastic Load Balancing health check status. This grace period can prevent the ECS service scheduler from marking tasks as unhealthy and stopping them before they have time to come up. -- `"networkConfiguration"`: +- `"networkConfiguration"`: An object representing the network configuration for the + service. - `"placementConstraints"`: An array of task placement constraint objects to update the service to use. If no value is specified, the existing placement constraints for the service will remain unchanged. If this value is specified, it will override any existing @@ -2022,7 +2041,8 @@ Service Developer Guide. # Arguments - `cluster`: The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service that the task set exists in. -- `scale`: +- `scale`: A floating-point percentage of the desired number of tasks to place and keep + running in the task set. - `service`: The short name or full Amazon Resource Name (ARN) of the service that the task set exists in. - `task_set`: The short name or full Amazon Resource Name (ARN) of the task set to update. diff --git a/src/services/finspace.jl b/src/services/finspace.jl new file mode 100644 index 0000000000..6adc527141 --- /dev/null +++ b/src/services/finspace.jl @@ -0,0 +1,132 @@ +# This file is auto-generated by AWSMetadata.jl +using AWS +using AWS.AWSServices: finspace +using AWS.Compat +using AWS.UUIDs + +""" + create_environment(name) + create_environment(name, params::Dict{String,<:Any}) + +Create a new FinSpace environment. + +# Arguments +- `name`: The name of the FinSpace environment to be created. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"description"`: The description of the FinSpace environment to be created. +- `"federationMode"`: Authentication mode for the environment. FEDERATED - Users access + FinSpace through Single Sign On (SSO) via your Identity provider. LOCAL - Users access + FinSpace via email and password managed within the FinSpace environment. +- `"federationParameters"`: Configuration information when authentication mode is FEDERATED. +- `"kmsKeyId"`: The KMS key id to encrypt your data in the FinSpace environment. +- `"tags"`: Add tags to your FinSpace environment. +""" +create_environment(name; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("POST", "/environment", Dict{String, Any}("name"=>name); aws_config=aws_config) +create_environment(name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("POST", "/environment", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("name"=>name), params)); aws_config=aws_config) + +""" + delete_environment(environment_id) + delete_environment(environment_id, params::Dict{String,<:Any}) + +Delete an FinSpace environment. + +# Arguments +- `environment_id`: The identifier for the FinSpace environment. + +""" +delete_environment(environmentId; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("DELETE", "/environment/$(environmentId)"; aws_config=aws_config) +delete_environment(environmentId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("DELETE", "/environment/$(environmentId)", params; aws_config=aws_config) + +""" + get_environment(environment_id) + get_environment(environment_id, params::Dict{String,<:Any}) + +Returns the FinSpace environment object. + +# Arguments +- `environment_id`: The identifier of the FinSpace environment. + +""" +get_environment(environmentId; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("GET", "/environment/$(environmentId)"; aws_config=aws_config) +get_environment(environmentId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("GET", "/environment/$(environmentId)", params; aws_config=aws_config) + +""" + list_environments() + list_environments(params::Dict{String,<:Any}) + +A list of all of your FinSpace environments. + +# 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 this request. +- `"nextToken"`: A token generated by FinSpace that specifies where to continue pagination + if a previous request was truncated. To get the next set of pages, pass in the nextToken + value from the response object of the previous page call. +""" +list_environments(; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("GET", "/environment"; aws_config=aws_config) +list_environments(params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("GET", "/environment", params; aws_config=aws_config) + +""" + list_tags_for_resource(resource_arn) + list_tags_for_resource(resource_arn, params::Dict{String,<:Any}) + +A list of all tags for a resource. + +# Arguments +- `resource_arn`: The Amazon Resource Name of the resource. + +""" +list_tags_for_resource(resourceArn; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("GET", "/tags/$(resourceArn)"; aws_config=aws_config) +list_tags_for_resource(resourceArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("GET", "/tags/$(resourceArn)", params; aws_config=aws_config) + +""" + tag_resource(resource_arn, tags) + tag_resource(resource_arn, tags, params::Dict{String,<:Any}) + +Adds metadata tags to a FinSpace resource. + +# Arguments +- `resource_arn`: The Amazon Resource Name (ARN) for the resource. +- `tags`: One or more tags to be assigned to the resource. + +""" +tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("POST", "/tags/$(resourceArn)", Dict{String, Any}("tags"=>tags); aws_config=aws_config) +tag_resource(resourceArn, tags, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("POST", "/tags/$(resourceArn)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("tags"=>tags), params)); aws_config=aws_config) + +""" + untag_resource(resource_arn, tag_keys) + untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any}) + +Removes metadata tags from a FinSpace resource. + +# Arguments +- `resource_arn`: A FinSpace resource from which you want to remove a tag or tags. The + value for this parameter is an Amazon Resource Name (ARN). +- `tag_keys`: The tag keys (names) of one or more tags to be removed. + +""" +untag_resource(resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("DELETE", "/tags/$(resourceArn)", Dict{String, Any}("tagKeys"=>tagKeys); aws_config=aws_config) +untag_resource(resourceArn, tagKeys, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("DELETE", "/tags/$(resourceArn)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("tagKeys"=>tagKeys), params)); aws_config=aws_config) + +""" + update_environment(environment_id) + update_environment(environment_id, params::Dict{String,<:Any}) + +Update your FinSpace environment. + +# Arguments +- `environment_id`: The identifier of the FinSpace environment. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"description"`: The description of the environment. +- `"federationMode"`: Authentication mode for the environment. FEDERATED - Users access + FinSpace through Single Sign On (SSO) via your Identity provider. LOCAL - Users access + FinSpace via email and password managed within the FinSpace environment. +- `"federationParameters"`: +- `"name"`: The name of the environment. +""" +update_environment(environmentId; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("PUT", "/environment/$(environmentId)"; aws_config=aws_config) +update_environment(environmentId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = finspace("PUT", "/environment/$(environmentId)", params; aws_config=aws_config) diff --git a/src/services/finspace_data.jl b/src/services/finspace_data.jl new file mode 100644 index 0000000000..0876fe1f6c --- /dev/null +++ b/src/services/finspace_data.jl @@ -0,0 +1,65 @@ +# This file is auto-generated by AWSMetadata.jl +using AWS +using AWS.AWSServices: finspace_data +using AWS.Compat +using AWS.UUIDs + +""" + create_changeset(change_type, dataset_id, source_params, source_type) + create_changeset(change_type, dataset_id, source_params, source_type, params::Dict{String,<:Any}) + +Creates a new changeset in a FinSpace dataset. + +# Arguments +- `change_type`: Option to indicate how a changeset will be applied to a dataset. + REPLACE - Changeset will be considered as a replacement to all prior loaded changesets. + APPEND - Changeset will be considered as an addition to the end of all prior loaded + changesets. +- `dataset_id`: The unique identifier for the FinSpace dataset in which the changeset will + be created. +- `source_params`: Source path from which the files to create the changeset will be sourced. +- `source_type`: Type of the data source from which the files to create the changeset will + be sourced. S3 - Amazon S3. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"formatParams"`: Options that define the structure of the source file(s). +- `"formatType"`: Format type of the input files being loaded into the changeset. +- `"tags"`: Metadata tags to apply to this changeset. +""" +create_changeset(changeType, datasetId, sourceParams, sourceType; aws_config::AbstractAWSConfig=global_aws_config()) = finspace_data("POST", "/datasets/$(datasetId)/changesets", Dict{String, Any}("changeType"=>changeType, "sourceParams"=>sourceParams, "sourceType"=>sourceType); aws_config=aws_config) +create_changeset(changeType, datasetId, sourceParams, sourceType, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = finspace_data("POST", "/datasets/$(datasetId)/changesets", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("changeType"=>changeType, "sourceParams"=>sourceParams, "sourceType"=>sourceType), params)); aws_config=aws_config) + +""" + get_programmatic_access_credentials(environment_id) + get_programmatic_access_credentials(environment_id, params::Dict{String,<:Any}) + +Request programmatic credentials to use with Habanero SDK. + +# Arguments +- `environment_id`: The habanero environment identifier. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"durationInMinutes"`: The time duration in which the credentials remain valid. +""" +get_programmatic_access_credentials(environmentId; aws_config::AbstractAWSConfig=global_aws_config()) = finspace_data("GET", "/credentials/programmatic", Dict{String, Any}("environmentId"=>environmentId); aws_config=aws_config) +get_programmatic_access_credentials(environmentId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = finspace_data("GET", "/credentials/programmatic", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("environmentId"=>environmentId), params)); aws_config=aws_config) + +""" + get_working_location() + get_working_location(params::Dict{String,<:Any}) + +A temporary Amazon S3 location to copy your files from a source location to stage or use as +a scratch space in Habanero notebook. + +# Optional Parameters +Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are: +- `"locationType"`: Specify the type of the working location. SAGEMAKER - Use the Amazon + S3 location as a temporary location to store data content when working with FinSpace + Notebooks that run on SageMaker studio. INGESTION - Use the Amazon S3 location as a + staging location to copy your data content and then use the location with the changeset + creation operation. +""" +get_working_location(; aws_config::AbstractAWSConfig=global_aws_config()) = finspace_data("POST", "/workingLocationV1"; aws_config=aws_config) +get_working_location(params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = finspace_data("POST", "/workingLocationV1", params; aws_config=aws_config) diff --git a/src/services/forecast.jl b/src/services/forecast.jl index 1c552ead16..41957717bc 100644 --- a/src/services/forecast.jl +++ b/src/services/forecast.jl @@ -521,6 +521,28 @@ Deletes a predictor backtest export job. delete_predictor_backtest_export_job(PredictorBacktestExportJobArn; aws_config::AbstractAWSConfig=global_aws_config()) = forecast("DeletePredictorBacktestExportJob", Dict{String, Any}("PredictorBacktestExportJobArn"=>PredictorBacktestExportJobArn); aws_config=aws_config) delete_predictor_backtest_export_job(PredictorBacktestExportJobArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = forecast("DeletePredictorBacktestExportJob", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("PredictorBacktestExportJobArn"=>PredictorBacktestExportJobArn), params)); aws_config=aws_config) +""" + delete_resource_tree(resource_arn) + delete_resource_tree(resource_arn, params::Dict{String,<:Any}) + +Deletes an entire resource tree. This operation will delete the parent resource and its +child resources. Child resources are resources that were created from another resource. For +example, when a forecast is generated from a predictor, the forecast is the child resource +and the predictor is the parent resource. Amazon Forecast resources possess the following +parent-child resource hierarchies: Dataset Group: predictors, predictor backtest export +jobs, forecasts, forecast export jobs Dataset: dataset import jobs Predictor: +predictor backtest export jobs, forecasts, forecast export jobs Forecast: forecast +export jobs DeleteResourceTree will only delete Amazon Forecast resources, and will not +delete datasets or exported files stored in Amazon S3. + +# Arguments +- `resource_arn`: The Amazon Resource Name (ARN) of the parent resource to delete. All + child resources of the parent resource will also be deleted. + +""" +delete_resource_tree(ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()) = forecast("DeleteResourceTree", Dict{String, Any}("ResourceArn"=>ResourceArn); aws_config=aws_config) +delete_resource_tree(ResourceArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = forecast("DeleteResourceTree", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("ResourceArn"=>ResourceArn), params)); aws_config=aws_config) + """ describe_dataset(dataset_arn) describe_dataset(dataset_arn, params::Dict{String,<:Any}) diff --git a/src/services/macie2.jl b/src/services/macie2.jl index 0b86c8454b..76d5b035eb 100644 --- a/src/services/macie2.jl +++ b/src/services/macie2.jl @@ -98,7 +98,7 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys words. Each ignore word can contain 4 - 90 characters. Ignore words are case sensitive. - `"keywords"`: An array that lists specific character sequences (keywords), one of which must be within proximity (maximumMatchDistance) of the regular expression to match. The - array can contain as many as 50 keywords. Each keyword can contain 4 - 90 characters. + array can contain as many as 50 keywords. Each keyword can contain 3 - 90 characters. Keywords aren't case sensitive. - `"maximumMatchDistance"`: The maximum number of characters that can exist between text that matches the regex pattern and the character sequences specified by the keywords array. @@ -820,7 +820,7 @@ Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys words. Each ignore word can contain 4 - 90 characters. Ignore words are case sensitive. - `"keywords"`: An array that lists specific character sequences (keywords), one of which must be within proximity (maximumMatchDistance) of the regular expression to match. The - array can contain as many as 50 keywords. Each keyword can contain 4 - 90 characters. + array can contain as many as 50 keywords. Each keyword can contain 3 - 90 characters. Keywords aren't case sensitive. - `"maximumMatchDistance"`: The maximum number of characters that can exist between text that matches the regex pattern and the character sequences specified by the keywords array. diff --git a/src/services/marketplace_catalog.jl b/src/services/marketplace_catalog.jl index 3c965e8991..cb00636a9a 100644 --- a/src/services/marketplace_catalog.jl +++ b/src/services/marketplace_catalog.jl @@ -109,8 +109,9 @@ when a ChangeSet is running, all the entities targeted by the different changes until the ChangeSet has completed (either succeeded, cancelled, or failed). If you try to start a ChangeSet containing a change against an entity that is already locked, you will receive a ResourceInUseException. For example, you cannot start the ChangeSet described in -the example below because it contains two changes to execute the same change type -(AddRevisions) against the same entity (entity-id@1). +the example later in this topic, because it contains two changes to execute the same change +type (AddRevisions) against the same entity (entity-id@1). For more information about +working with change sets, see Working with change sets. # Arguments - `catalog`: The catalog related to the request. Fixed value: AWSMarketplace diff --git a/src/services/mturk.jl b/src/services/mturk.jl index c782c3de65..4c6c2c244e 100644 --- a/src/services/mturk.jl +++ b/src/services/mturk.jl @@ -461,8 +461,11 @@ disassociate_qualification_from_worker(QualificationTypeId, WorkerId, params::Ab get_account_balance() get_account_balance(params::Dict{String,<:Any}) -The GetAccountBalance operation retrieves the amount of money in your Amazon Mechanical -Turk account. +The GetAccountBalance operation retrieves the Prepaid HITs balance in your Amazon +Mechanical Turk account if you are a Prepaid Requester. Alternatively, this operation will +retrieve the remaining available AWS Billing usage if you have enabled AWS Billing. Note: +If you have enabled AWS Billing and still have a remaining Prepaid HITs balance, this +balance can be viewed on the My Account page in the Requester console. """ get_account_balance(; aws_config::AbstractAWSConfig=global_aws_config()) = mturk("GetAccountBalance"; aws_config=aws_config) diff --git a/src/services/organizations.jl b/src/services/organizations.jl index 4f42d25da8..6be2af3392 100644 --- a/src/services/organizations.jl +++ b/src/services/organizations.jl @@ -95,8 +95,8 @@ the request, do one of the following: Use the Id member of the CreateAccountSt response element from this operation to provide as a parameter to the DescribeCreateAccountStatus operation. Check the AWS CloudTrail log for the CreateAccountResult event. For information on using AWS CloudTrail with AWS Organizations, -see Monitoring the Activity in Your Organization in the AWS Organizations User Guide. -The user who calls the API to create an account must have the organizations:CreateAccount +see Logging and monitoring in AWS Organizations in the AWS Organizations User Guide. The +user who calls the API to create an account must have the organizations:CreateAccount permission. If you enabled all features in the organization, AWS Organizations creates the required service-linked role named AWSServiceRoleForOrganizations. For more information, see AWS Organizations and Service-Linked Roles in the AWS Organizations User Guide. If the @@ -868,7 +868,9 @@ enable IAM user access to billing in your account. For more information, see Act Access to the Billing and Cost Management Console in the AWS Billing and Cost Management User Guide. After the account leaves the organization, all tags that were attached to the account object in the organization are deleted. AWS accounts outside of an organization -do not support tags. +do not support tags. A newly created account has a waiting period before it can be +removed from its organization. If you get an error that indicates that a wait period is +required, then try again in a few days. """ leave_organization(; aws_config::AbstractAWSConfig=global_aws_config()) = organizations("LeaveOrganization"; aws_config=aws_config) diff --git a/src/services/personalize.jl b/src/services/personalize.jl index 6fd41d51db..28729391ae 100644 --- a/src/services/personalize.jl +++ b/src/services/personalize.jl @@ -100,13 +100,13 @@ create_dataset(datasetGroupArn, datasetType, name, schemaArn, params::AbstractDi Creates a job that exports data from your dataset to an Amazon S3 bucket. To allow Amazon Personalize to export the training data, you must specify an service-linked AWS Identity and Access Management (IAM) role that gives Amazon Personalize PutObject permissions for -your Amazon S3 bucket. For information, see Dataset export job permissions requirements in -the Amazon Personalize developer guide. Status A dataset export job can be in one of the -following states: CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED - To get the status of the export job, call DescribeDatasetExportJob, and specify the Amazon -Resource Name (ARN) of the dataset export job. The dataset export is complete when the -status shows as ACTIVE. If the status shows as CREATE FAILED, the response includes a -failureReason key, which describes why the job failed. +your Amazon S3 bucket. For information, see Exporting a dataset in the Amazon Personalize +developer guide. Status A dataset export job can be in one of the following states: +CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED To get the status +of the export job, call DescribeDatasetExportJob, and specify the Amazon Resource Name +(ARN) of the dataset export job. The dataset export is complete when the status shows as +ACTIVE. If the status shows as CREATE FAILED, the response includes a failureReason key, +which describes why the job failed. # Arguments - `dataset_arn`: The Amazon Resource Name (ARN) of the dataset that contains the data to diff --git a/src/services/securityhub.jl b/src/services/securityhub.jl index 8d13fb8b57..36059b5ef4 100644 --- a/src/services/securityhub.jl +++ b/src/services/securityhub.jl @@ -28,7 +28,12 @@ accept_administrator_invitation(AdministratorId, InvitationId, params::AbstractD accept_invitation(invitation_id, master_id) accept_invitation(invitation_id, master_id, params::Dict{String,<:Any}) -This method is deprecated. Instead, use AcceptAdministratorInvitation. Accepts the +This method is deprecated. Instead, use AcceptAdministratorInvitation. The Security Hub +console continues to use AcceptInvitation. It will eventually change to use +AcceptAdministratorInvitation. Any IAM policies that specifically control access to this +function must continue to use AcceptInvitation. You should also add +AcceptAdministratorInvitation to your policies to ensure that the correct permissions are +in place after the console begins to use AcceptAdministratorInvitation. Accepts the invitation to be a member account and be monitored by the Security Hub administrator account that the invitation was sent from. This operation is only used by member accounts that are not added through Organizations. When the member account accepts the invitation, @@ -456,10 +461,16 @@ disassociate_from_administrator_account(params::AbstractDict{String}; aws_config disassociate_from_master_account() disassociate_from_master_account(params::Dict{String,<:Any}) -This method is deprecated. Instead, use DisassociateFromAdministratorAccount. Disassociates -the current Security Hub member account from the associated administrator account. This -operation is only used by accounts that are not part of an organization. For organization -accounts, only the administrator account can disassociate a member account. +This method is deprecated. Instead, use DisassociateFromAdministratorAccount. The Security +Hub console continues to use DisassociateFromMasterAccount. It will eventually change to +use DisassociateFromAdministratorAccount. Any IAM policies that specifically control access +to this function must continue to use DisassociateFromMasterAccount. You should also add +DisassociateFromAdministratorAccount to your policies to ensure that the correct +permissions are in place after the console begins to use +DisassociateFromAdministratorAccount. Disassociates the current Security Hub member account +from the associated administrator account. This operation is only used by accounts that are +not part of an organization. For organization accounts, only the administrator account can +disassociate a member account. """ disassociate_from_master_account(; aws_config::AbstractAWSConfig=global_aws_config()) = securityhub("POST", "/master/disassociate"; aws_config=aws_config) @@ -638,10 +649,14 @@ get_invitations_count(params::AbstractDict{String}; aws_config::AbstractAWSConfi get_master_account() get_master_account(params::Dict{String,<:Any}) -This method is deprecated. Instead, use GetAdministratorAccount. Provides the details for -the Security Hub administrator account for the current member account. Can be used by both -member accounts that are managed using Organizations and accounts that were invited -manually. +This method is deprecated. Instead, use GetAdministratorAccount. The Security Hub console +continues to use GetMasterAccount. It will eventually change to use +GetAdministratorAccount. Any IAM policies that specifically control access to this function +must continue to use GetMasterAccount. You should also add GetAdministratorAccount to your +policies to ensure that the correct permissions are in place after the console begins to +use GetAdministratorAccount. Provides the details for the Security Hub administrator +account for the current member account. Can be used by both member accounts that are +managed using Organizations and accounts that were invited manually. """ get_master_account(; aws_config::AbstractAWSConfig=global_aws_config()) = securityhub("GET", "/master"; aws_config=aws_config)