From 6b003f7b0b2de0cb172092cc19c1ac7b73922fa3 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 13 Jun 2024 01:43:14 +0000 Subject: [PATCH] Update services based on release-2024-06-12 of AWS Go SDK Reference: https://github.com/aws/aws-sdk-go-v2/releases/tag/release-2024-06-12 --- .latest-tag-aws-sdk-go | 2 +- lib/aws/generated/app_test.ex | 2486 ++++++++++++++++++++++++++ lib/aws/generated/backup_storage.ex | 793 -------- lib/aws/generated/ec2.ex | 51 +- lib/aws/generated/osis.ex | 4 +- lib/aws/generated/redshift.ex | 12 - lib/aws/generated/secrets_manager.ex | 7 +- lib/aws/generated/sesv2.ex | 39 +- 8 files changed, 2565 insertions(+), 829 deletions(-) create mode 100644 lib/aws/generated/app_test.ex delete mode 100644 lib/aws/generated/backup_storage.ex diff --git a/.latest-tag-aws-sdk-go b/.latest-tag-aws-sdk-go index bff92a0f..360db87c 100644 --- a/.latest-tag-aws-sdk-go +++ b/.latest-tag-aws-sdk-go @@ -1 +1 @@ -release-2024-06-11 +release-2024-06-12 diff --git a/lib/aws/generated/app_test.ex b/lib/aws/generated/app_test.ex new file mode 100644 index 00000000..a0fae07e --- /dev/null +++ b/lib/aws/generated/app_test.ex @@ -0,0 +1,2486 @@ +# WARNING: DO NOT EDIT, AUTO-GENERATED CODE! +# See https://github.com/aws-beam/aws-codegen for more details. + +defmodule AWS.AppTest do + @moduledoc """ + AWS Mainframe Modernization Application Testing provides tools and resources for + automated functional equivalence testing for your migration projects. + """ + + alias AWS.Client + alias AWS.Request + + @typedoc """ + + ## Example: + + create_test_configuration_response() :: %{ + "testConfigurationId" => String.t(), + "testConfigurationVersion" => integer() + } + + """ + @type create_test_configuration_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + get_test_configuration_request() :: %{ + optional("testConfigurationVersion") => integer() + } + + """ + @type get_test_configuration_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + delete_test_suite_request() :: %{} + + """ + @type delete_test_suite_request() :: %{} + + @typedoc """ + + ## Example: + + update_test_configuration_response() :: %{ + "testConfigurationId" => String.t(), + "testConfigurationVersion" => integer() + } + + """ + @type update_test_configuration_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + tag_resource_request() :: %{ + required("tags") => map() + } + + """ + @type tag_resource_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + delete_test_case_response() :: %{} + + """ + @type delete_test_case_response() :: %{} + + @typedoc """ + + ## Example: + + delete_test_run_response() :: %{} + + """ + @type delete_test_run_response() :: %{} + + @typedoc """ + + ## Example: + + m2_non_managed_application_step_input() :: %{ + "actionType" => list(any()), + "listenerPort" => [integer()], + "runtime" => list(any()), + "vpcEndpointServiceName" => [String.t()], + "webAppName" => [String.t()] + } + + """ + @type m2_non_managed_application_step_input() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + batch_step_output() :: %{ + "dataSetDetails" => list(data_set()()), + "dataSetExportLocation" => String.t(), + "dmsOutputLocation" => String.t() + } + + """ + @type batch_step_output() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + untag_resource_response() :: %{} + + """ + @type untag_resource_response() :: %{} + + @typedoc """ + + ## Example: + + create_cloud_formation_summary() :: %{ + "stepInput" => create_cloud_formation_step_input(), + "stepOutput" => create_cloud_formation_step_output() + } + + """ + @type create_cloud_formation_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_test_run_test_cases_response() :: %{ + "nextToken" => String.t(), + "testRunTestCases" => list(test_case_run_summary()()) + } + + """ + @type list_test_run_test_cases_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + delete_cloud_formation_step_output() :: %{} + + """ + @type delete_cloud_formation_step_output() :: %{} + + @typedoc """ + + ## Example: + + data_set() :: %{ + "ccsid" => String.t(), + "format" => list(any()), + "length" => [integer()], + "name" => String.t(), + "type" => list(any()) + } + + """ + @type data_set() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + input_file() :: %{ + "fileMetadata" => list(), + "sourceLocation" => String.t(), + "targetLocation" => String.t() + } + + """ + @type input_file() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + delete_cloud_formation_step_input() :: %{ + "stackId" => [String.t()] + } + + """ + @type delete_cloud_formation_step_input() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + delete_test_suite_response() :: %{} + + """ + @type delete_test_suite_response() :: %{} + + @typedoc """ + + ## Example: + + m2_non_managed_application() :: %{ + "listenerPort" => String.t(), + "runtime" => list(any()), + "vpcEndpointServiceName" => String.t(), + "webAppName" => String.t() + } + + """ + @type m2_non_managed_application() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + compare_data_sets_summary() :: %{ + "stepInput" => compare_data_sets_step_input(), + "stepOutput" => compare_data_sets_step_output() + } + + """ + @type compare_data_sets_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + cloud_formation() :: %{ + "parameters" => map(), + "templateLocation" => String.t() + } + + """ + @type cloud_formation() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + create_test_suite_request() :: %{ + optional("afterSteps") => list(step()()), + optional("beforeSteps") => list(step()()), + optional("clientToken") => String.t(), + optional("description") => String.t(), + optional("tags") => map(), + required("name") => String.t(), + required("testCases") => list() + } + + """ + @type create_test_suite_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_test_suites_request() :: %{ + optional("maxResults") => integer(), + optional("nextToken") => String.t(), + optional("testSuiteIds") => list(String.t()()) + } + + """ + @type list_test_suites_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + script_summary() :: %{ + "scriptLocation" => String.t(), + "type" => list(any()) + } + + """ + @type script_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + delete_test_run_request() :: %{} + + """ + @type delete_test_run_request() :: %{} + + @typedoc """ + + ## Example: + + compare_database_c_d_c_step_output() :: %{ + "comparisonOutputLocation" => [String.t()], + "comparisonStatus" => list(any()) + } + + """ + @type compare_database_c_d_c_step_output() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + m2_non_managed_application_step_output() :: %{} + + """ + @type m2_non_managed_application_step_output() :: %{} + + @typedoc """ + + ## Example: + + m2_managed_application() :: %{ + "applicationId" => String.t(), + "listenerPort" => String.t(), + "runtime" => list(any()), + "vpcEndpointServiceName" => String.t() + } + + """ + @type m2_managed_application() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + untag_resource_request() :: %{ + required("tagKeys") => list(String.t()()) + } + + """ + @type untag_resource_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_test_run_steps_request() :: %{ + optional("maxResults") => integer(), + optional("nextToken") => String.t(), + optional("testCaseId") => String.t(), + optional("testSuiteId") => String.t() + } + + """ + @type list_test_run_steps_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + compare_database_c_d_c_step_input() :: %{ + "outputLocation" => [String.t()], + "sourceLocation" => [String.t()], + "sourceMetadata" => source_database_metadata(), + "targetLocation" => [String.t()], + "targetMetadata" => target_database_metadata() + } + + """ + @type compare_database_c_d_c_step_input() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + delete_test_configuration_response() :: %{} + + """ + @type delete_test_configuration_response() :: %{} + + @typedoc """ + + ## Example: + + test_case_summary() :: %{ + "creationTime" => [non_neg_integer()], + "lastUpdateTime" => [non_neg_integer()], + "latestVersion" => integer(), + "name" => String.t(), + "status" => list(any()), + "statusReason" => [String.t()], + "testCaseArn" => String.t(), + "testCaseId" => String.t() + } + + """ + @type test_case_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + compare_action_summary() :: %{ + "type" => list() + } + + """ + @type compare_action_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_test_cases_response() :: %{ + "nextToken" => String.t(), + "testCases" => list(test_case_summary()()) + } + + """ + @type list_test_cases_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + create_test_case_request() :: %{ + optional("clientToken") => String.t(), + optional("description") => String.t(), + optional("tags") => map(), + required("name") => String.t(), + required("steps") => list(step()()) + } + + """ + @type create_test_case_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + m2_non_managed_application_action() :: %{ + "actionType" => list(any()), + "resource" => String.t() + } + + """ + @type m2_non_managed_application_action() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + test_suite_latest_version() :: %{ + "status" => list(any()), + "statusReason" => [String.t()], + "version" => integer() + } + + """ + @type test_suite_latest_version() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + get_test_run_step_response() :: %{ + "afterStep" => [boolean()], + "beforeStep" => [boolean()], + "runEndTime" => [non_neg_integer()], + "runStartTime" => [non_neg_integer()], + "status" => list(any()), + "statusReason" => [String.t()], + "stepName" => String.t(), + "stepRunSummary" => list(), + "testCaseId" => String.t(), + "testCaseVersion" => integer(), + "testRunId" => String.t(), + "testSuiteId" => String.t(), + "testSuiteVersion" => integer() + } + + """ + @type get_test_run_step_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + test_configuration_latest_version() :: %{ + "status" => list(any()), + "statusReason" => [String.t()], + "version" => integer() + } + + """ + @type test_configuration_latest_version() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_test_configurations_request() :: %{ + optional("maxResults") => integer(), + optional("nextToken") => String.t(), + optional("testConfigurationIds") => list(String.t()()) + } + + """ + @type list_test_configurations_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + get_test_run_step_request() :: %{ + optional("testCaseId") => String.t(), + optional("testSuiteId") => String.t() + } + + """ + @type get_test_run_step_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + conflict_exception() :: %{ + "message" => [String.t()], + "resourceId" => [String.t()], + "resourceType" => [String.t()] + } + + """ + @type conflict_exception() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + resource_not_found_exception() :: %{ + "message" => [String.t()], + "resourceId" => [String.t()], + "resourceType" => [String.t()] + } + + """ + @type resource_not_found_exception() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + m2_managed_application_step_input() :: %{ + "actionType" => list(any()), + "applicationId" => [String.t()], + "listenerPort" => [integer()], + "properties" => m2_managed_action_properties(), + "runtime" => [String.t()], + "vpcEndpointServiceName" => [String.t()] + } + + """ + @type m2_managed_application_step_input() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + test_suite_summary() :: %{ + "creationTime" => [non_neg_integer()], + "lastUpdateTime" => [non_neg_integer()], + "latestVersion" => integer(), + "name" => String.t(), + "status" => list(any()), + "statusReason" => [String.t()], + "testSuiteArn" => String.t(), + "testSuiteId" => String.t() + } + + """ + @type test_suite_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + m2_managed_application_action() :: %{ + "actionType" => list(any()), + "properties" => m2_managed_action_properties(), + "resource" => String.t() + } + + """ + @type m2_managed_application_action() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + test_case_run_summary() :: %{ + "runEndTime" => [non_neg_integer()], + "runStartTime" => [non_neg_integer()], + "status" => list(any()), + "statusReason" => [String.t()], + "testCaseId" => String.t(), + "testCaseVersion" => integer(), + "testRunId" => String.t() + } + + """ + @type test_case_run_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + service_quota_exceeded_exception() :: %{ + "message" => [String.t()], + "quotaCode" => [String.t()], + "resourceId" => [String.t()], + "resourceType" => [String.t()], + "serviceCode" => [String.t()] + } + + """ + @type service_quota_exceeded_exception() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + create_test_suite_response() :: %{ + "testSuiteId" => String.t(), + "testSuiteVersion" => integer() + } + + """ + @type create_test_suite_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + mainframe_action() :: %{ + "actionType" => list(), + "properties" => mainframe_action_properties(), + "resource" => String.t() + } + + """ + @type mainframe_action() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + source_database_metadata() :: %{ + "captureTool" => list(any()), + "type" => list(any()) + } + + """ + @type source_database_metadata() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + get_test_suite_request() :: %{ + optional("testSuiteVersion") => integer() + } + + """ + @type get_test_suite_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_test_suites_response() :: %{ + "nextToken" => String.t(), + "testSuites" => list(test_suite_summary()()) + } + + """ + @type list_test_suites_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + delete_cloud_formation_summary() :: %{ + "stepInput" => delete_cloud_formation_step_input(), + "stepOutput" => delete_cloud_formation_step_output() + } + + """ + @type delete_cloud_formation_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_tags_for_resource_response() :: %{ + "tags" => map() + } + + """ + @type list_tags_for_resource_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + validation_exception_field() :: %{ + "message" => [String.t()], + "name" => [String.t()] + } + + """ + @type validation_exception_field() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + test_configuration_summary() :: %{ + "creationTime" => [non_neg_integer()], + "lastUpdateTime" => [non_neg_integer()], + "latestVersion" => integer(), + "name" => String.t(), + "status" => list(any()), + "statusReason" => [String.t()], + "testConfigurationArn" => String.t(), + "testConfigurationId" => String.t() + } + + """ + @type test_configuration_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + start_test_run_response() :: %{ + "testRunId" => String.t(), + "testRunStatus" => list(any()) + } + + """ + @type start_test_run_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + target_database_metadata() :: %{ + "captureTool" => list(any()), + "type" => list(any()) + } + + """ + @type target_database_metadata() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + delete_test_case_request() :: %{} + + """ + @type delete_test_case_request() :: %{} + + @typedoc """ + + ## Example: + + t_n3270_summary() :: %{ + "stepInput" => t_n3270_step_input(), + "stepOutput" => t_n3270_step_output() + } + + """ + @type t_n3270_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + update_test_suite_request() :: %{ + optional("afterSteps") => list(step()()), + optional("beforeSteps") => list(step()()), + optional("description") => String.t(), + optional("testCases") => list() + } + + """ + @type update_test_suite_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + create_cloud_formation_step_input() :: %{ + "parameters" => map(), + "templateLocation" => String.t() + } + + """ + @type create_cloud_formation_step_input() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + m2_managed_application_summary() :: %{ + "applicationId" => String.t(), + "listenerPort" => [integer()], + "runtime" => list(any()) + } + + """ + @type m2_managed_application_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + output_file() :: %{ + "fileLocation" => String.t() + } + + """ + @type output_file() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + internal_server_exception() :: %{ + "message" => [String.t()], + "retryAfterSeconds" => [integer()] + } + + """ + @type internal_server_exception() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + batch_summary() :: %{ + "stepInput" => batch_step_input(), + "stepOutput" => batch_step_output() + } + + """ + @type batch_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + m2_managed_application_step_summary() :: %{ + "stepInput" => m2_managed_application_step_input(), + "stepOutput" => m2_managed_application_step_output() + } + + """ + @type m2_managed_application_step_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + batch_step_input() :: %{ + "batchJobName" => String.t(), + "batchJobParameters" => map(), + "exportDataSetNames" => list(String.t()()), + "properties" => mainframe_action_properties(), + "resource" => list() + } + + """ + @type batch_step_input() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + access_denied_exception() :: %{ + "message" => [String.t()] + } + + """ + @type access_denied_exception() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + update_test_case_request() :: %{ + optional("description") => String.t(), + optional("steps") => list(step()()) + } + + """ + @type update_test_case_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_test_cases_request() :: %{ + optional("maxResults") => integer(), + optional("nextToken") => String.t(), + optional("testCaseIds") => list(String.t()()) + } + + """ + @type list_test_cases_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + database_c_d_c() :: %{ + "sourceMetadata" => source_database_metadata(), + "targetMetadata" => target_database_metadata() + } + + """ + @type database_c_d_c() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + tag_resource_response() :: %{} + + """ + @type tag_resource_response() :: %{} + + @typedoc """ + + ## Example: + + mainframe_action_properties() :: %{ + "dmsTaskArn" => String.t() + } + + """ + @type mainframe_action_properties() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + test_case_latest_version() :: %{ + "status" => list(any()), + "statusReason" => [String.t()], + "version" => integer() + } + + """ + @type test_case_latest_version() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + update_test_suite_response() :: %{ + "testSuiteId" => String.t(), + "testSuiteVersion" => integer() + } + + """ + @type update_test_suite_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + service_settings() :: %{ + "kmsKeyId" => [String.t()] + } + + """ + @type service_settings() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_test_run_steps_response() :: %{ + "nextToken" => String.t(), + "testRunSteps" => list(test_run_step_summary()()) + } + + """ + @type list_test_run_steps_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + get_test_configuration_response() :: %{ + "creationTime" => [non_neg_integer()], + "description" => String.t(), + "lastUpdateTime" => [non_neg_integer()], + "latestVersion" => test_configuration_latest_version(), + "name" => String.t(), + "properties" => map(), + "resources" => list(resource()()), + "serviceSettings" => service_settings(), + "status" => list(any()), + "statusReason" => [String.t()], + "tags" => map(), + "testConfigurationArn" => String.t(), + "testConfigurationId" => String.t(), + "testConfigurationVersion" => integer() + } + + """ + @type get_test_configuration_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + batch() :: %{ + "batchJobName" => String.t(), + "batchJobParameters" => map(), + "exportDataSetNames" => list(String.t()()) + } + + """ + @type batch() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + validation_exception() :: %{ + "fieldList" => list(validation_exception_field()()), + "message" => [String.t()], + "reason" => list(any()) + } + + """ + @type validation_exception() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_tags_for_resource_request() :: %{} + + """ + @type list_tags_for_resource_request() :: %{} + + @typedoc """ + + ## Example: + + m2_non_managed_application_step_summary() :: %{ + "stepInput" => m2_non_managed_application_step_input(), + "stepOutput" => m2_non_managed_application_step_output() + } + + """ + @type m2_non_managed_application_step_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_test_run_test_cases_request() :: %{ + optional("maxResults") => integer(), + optional("nextToken") => String.t() + } + + """ + @type list_test_run_test_cases_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + compare_action() :: %{ + "input" => list(), + "output" => list() + } + + """ + @type compare_action() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + get_test_suite_response() :: %{ + "afterSteps" => list(step()()), + "beforeSteps" => list(step()()), + "creationTime" => [non_neg_integer()], + "description" => String.t(), + "lastUpdateTime" => [non_neg_integer()], + "latestVersion" => test_suite_latest_version(), + "name" => String.t(), + "status" => list(any()), + "statusReason" => [String.t()], + "tags" => map(), + "testCases" => list(), + "testSuiteArn" => String.t(), + "testSuiteId" => String.t(), + "testSuiteVersion" => integer() + } + + """ + @type get_test_suite_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + script() :: %{ + "scriptLocation" => String.t(), + "type" => list(any()) + } + + """ + @type script() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + throttling_exception() :: %{ + "message" => [String.t()], + "quotaCode" => [String.t()], + "retryAfterSeconds" => [integer()], + "serviceCode" => [String.t()] + } + + """ + @type throttling_exception() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + t_n3270() :: %{ + "exportDataSetNames" => list(String.t()()), + "script" => script() + } + + """ + @type t_n3270() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + compare_database_c_d_c_summary() :: %{ + "stepInput" => compare_database_c_d_c_step_input(), + "stepOutput" => compare_database_c_d_c_step_output() + } + + """ + @type compare_database_c_d_c_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + compare_data_sets_step_input() :: %{ + "sourceDataSets" => list(data_set()()), + "sourceLocation" => String.t(), + "targetDataSets" => list(data_set()()), + "targetLocation" => String.t() + } + + """ + @type compare_data_sets_step_input() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + m2_non_managed_application_summary() :: %{ + "listenerPort" => [integer()], + "runtime" => list(any()), + "vpcEndpointServiceName" => [String.t()], + "webAppName" => [String.t()] + } + + """ + @type m2_non_managed_application_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_test_runs_response() :: %{ + "nextToken" => String.t(), + "testRuns" => list(test_run_summary()()) + } + + """ + @type list_test_runs_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + test_run_step_summary() :: %{ + "afterStep" => [boolean()], + "beforeStep" => [boolean()], + "runEndTime" => [non_neg_integer()], + "runStartTime" => [non_neg_integer()], + "status" => list(any()), + "statusReason" => [String.t()], + "stepName" => String.t(), + "testCaseId" => String.t(), + "testCaseVersion" => integer(), + "testRunId" => String.t(), + "testSuiteId" => String.t(), + "testSuiteVersion" => integer() + } + + """ + @type test_run_step_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + cloud_formation_action() :: %{ + "actionType" => list(any()), + "resource" => String.t() + } + + """ + @type cloud_formation_action() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + create_test_case_response() :: %{ + "testCaseId" => String.t(), + "testCaseVersion" => integer() + } + + """ + @type create_test_case_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + m2_managed_application_step_output() :: %{ + "importDataSetSummary" => map() + } + + """ + @type m2_managed_application_step_output() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + m2_managed_action_properties() :: %{ + "forceStop" => [boolean()], + "importDataSetLocation" => String.t() + } + + """ + @type m2_managed_action_properties() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + t_n3270_step_output() :: %{ + "dataSetDetails" => list(data_set()()), + "dataSetExportLocation" => String.t(), + "dmsOutputLocation" => String.t(), + "scriptOutputLocation" => String.t() + } + + """ + @type t_n3270_step_output() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + create_cloud_formation_step_output() :: %{ + "exports" => map(), + "stackId" => [String.t()] + } + + """ + @type create_cloud_formation_step_output() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + step() :: %{ + "action" => list(), + "description" => String.t(), + "name" => String.t() + } + + """ + @type step() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + t_n3270_step_input() :: %{ + "exportDataSetNames" => list(String.t()()), + "properties" => mainframe_action_properties(), + "resource" => list(), + "script" => script_summary() + } + + """ + @type t_n3270_step_input() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + update_test_case_response() :: %{ + "testCaseId" => String.t(), + "testCaseVersion" => integer() + } + + """ + @type update_test_case_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_test_configurations_response() :: %{ + "nextToken" => String.t(), + "testConfigurations" => list(test_configuration_summary()()) + } + + """ + @type list_test_configurations_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + get_test_case_request() :: %{ + optional("testCaseVersion") => integer() + } + + """ + @type get_test_case_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + compare_data_sets_step_output() :: %{ + "comparisonOutputLocation" => String.t(), + "comparisonStatus" => list(any()) + } + + """ + @type compare_data_sets_step_output() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + test_run_summary() :: %{ + "runEndTime" => [non_neg_integer()], + "runStartTime" => [non_neg_integer()], + "status" => list(any()), + "statusReason" => [String.t()], + "testConfigurationId" => String.t(), + "testConfigurationVersion" => integer(), + "testRunArn" => String.t(), + "testRunId" => String.t(), + "testSuiteId" => String.t(), + "testSuiteVersion" => integer() + } + + """ + @type test_run_summary() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + delete_test_configuration_request() :: %{} + + """ + @type delete_test_configuration_request() :: %{} + + @typedoc """ + + ## Example: + + create_test_configuration_request() :: %{ + optional("clientToken") => String.t(), + optional("description") => String.t(), + optional("properties") => map(), + optional("serviceSettings") => service_settings(), + optional("tags") => map(), + required("name") => String.t(), + required("resources") => list(resource()()) + } + + """ + @type create_test_configuration_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + get_test_case_response() :: %{ + "creationTime" => [non_neg_integer()], + "description" => String.t(), + "lastUpdateTime" => [non_neg_integer()], + "latestVersion" => test_case_latest_version(), + "name" => String.t(), + "status" => list(any()), + "statusReason" => [String.t()], + "steps" => list(step()()), + "tags" => map(), + "testCaseArn" => String.t(), + "testCaseId" => String.t(), + "testCaseVersion" => integer() + } + + """ + @type get_test_case_response() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + list_test_runs_request() :: %{ + optional("maxResults") => integer(), + optional("nextToken") => String.t(), + optional("testRunIds") => list(String.t()()), + optional("testSuiteId") => String.t() + } + + """ + @type list_test_runs_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + update_test_configuration_request() :: %{ + optional("description") => String.t(), + optional("properties") => map(), + optional("resources") => list(resource()()), + optional("serviceSettings") => service_settings() + } + + """ + @type update_test_configuration_request() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + resource() :: %{ + "name" => String.t(), + "type" => list() + } + + """ + @type resource() :: %{String.t() => any()} + + @typedoc """ + + ## Example: + + start_test_run_request() :: %{ + optional("clientToken") => String.t(), + optional("tags") => map(), + optional("testConfigurationId") => String.t(), + required("testSuiteId") => String.t() + } + + """ + @type start_test_run_request() :: %{String.t() => any()} + + @type create_test_case_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | service_quota_exceeded_exception() + | conflict_exception() + + @type create_test_configuration_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | service_quota_exceeded_exception() + | conflict_exception() + + @type create_test_suite_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | service_quota_exceeded_exception() + | conflict_exception() + + @type delete_test_case_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + | conflict_exception() + + @type delete_test_configuration_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | service_quota_exceeded_exception() + | conflict_exception() + + @type delete_test_run_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | conflict_exception() + + @type delete_test_suite_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | service_quota_exceeded_exception() + | conflict_exception() + + @type get_test_case_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + + @type get_test_configuration_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + + @type get_test_run_step_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + + @type get_test_suite_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + + @type list_tags_for_resource_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + + @type list_test_cases_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + + @type list_test_configurations_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + + @type list_test_run_steps_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + + @type list_test_run_test_cases_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + + @type list_test_runs_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + + @type list_test_suites_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + + @type start_test_run_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | service_quota_exceeded_exception() + | resource_not_found_exception() + | conflict_exception() + + @type tag_resource_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | service_quota_exceeded_exception() + | resource_not_found_exception() + + @type untag_resource_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + + @type update_test_case_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + | conflict_exception() + + @type update_test_configuration_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + | conflict_exception() + + @type update_test_suite_errors() :: + throttling_exception() + | validation_exception() + | access_denied_exception() + | internal_server_exception() + | resource_not_found_exception() + | conflict_exception() + + def metadata do + %{ + api_version: "2022-12-06", + content_type: "application/x-amz-json-1.1", + credential_scope: nil, + endpoint_prefix: "apptest", + global?: false, + hostname: nil, + protocol: "rest-json", + service_id: "AppTest", + signature_version: "v4", + signing_name: "apptest", + target_prefix: nil + } + end + + @doc """ + Creates a test case. + """ + @spec create_test_case(map(), create_test_case_request(), list()) :: + {:ok, create_test_case_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, create_test_case_errors()} + def create_test_case(%Client{} = client, input, options \\ []) do + url_path = "/testcase" + headers = [] + query_params = [] + + meta = metadata() + + Request.request_rest( + client, + meta, + :post, + url_path, + query_params, + headers, + input, + options, + 201 + ) + end + + @doc """ + Creates a test configuration. + """ + @spec create_test_configuration(map(), create_test_configuration_request(), list()) :: + {:ok, create_test_configuration_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, create_test_configuration_errors()} + def create_test_configuration(%Client{} = client, input, options \\ []) do + url_path = "/testconfiguration" + headers = [] + query_params = [] + + meta = metadata() + + Request.request_rest( + client, + meta, + :post, + url_path, + query_params, + headers, + input, + options, + 201 + ) + end + + @doc """ + Creates a test suite. + """ + @spec create_test_suite(map(), create_test_suite_request(), list()) :: + {:ok, create_test_suite_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, create_test_suite_errors()} + def create_test_suite(%Client{} = client, input, options \\ []) do + url_path = "/testsuite" + headers = [] + query_params = [] + + meta = metadata() + + Request.request_rest( + client, + meta, + :post, + url_path, + query_params, + headers, + input, + options, + 201 + ) + end + + @doc """ + Deletes a test case. + """ + @spec delete_test_case(map(), String.t(), delete_test_case_request(), list()) :: + {:ok, delete_test_case_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, delete_test_case_errors()} + def delete_test_case(%Client{} = client, test_case_id, input, options \\ []) do + url_path = "/testcases/#{AWS.Util.encode_uri(test_case_id)}" + headers = [] + query_params = [] + + meta = metadata() + + Request.request_rest( + client, + meta, + :delete, + url_path, + query_params, + headers, + input, + options, + 204 + ) + end + + @doc """ + Deletes a test configuration. + """ + @spec delete_test_configuration(map(), String.t(), delete_test_configuration_request(), list()) :: + {:ok, delete_test_configuration_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, delete_test_configuration_errors()} + def delete_test_configuration(%Client{} = client, test_configuration_id, input, options \\ []) do + url_path = "/testconfigurations/#{AWS.Util.encode_uri(test_configuration_id)}" + headers = [] + query_params = [] + + meta = metadata() + + Request.request_rest( + client, + meta, + :delete, + url_path, + query_params, + headers, + input, + options, + 204 + ) + end + + @doc """ + Deletes a test run. + """ + @spec delete_test_run(map(), String.t(), delete_test_run_request(), list()) :: + {:ok, delete_test_run_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, delete_test_run_errors()} + def delete_test_run(%Client{} = client, test_run_id, input, options \\ []) do + url_path = "/testruns/#{AWS.Util.encode_uri(test_run_id)}" + headers = [] + query_params = [] + + meta = metadata() + + Request.request_rest( + client, + meta, + :delete, + url_path, + query_params, + headers, + input, + options, + 204 + ) + end + + @doc """ + Deletes a test suite. + """ + @spec delete_test_suite(map(), String.t(), delete_test_suite_request(), list()) :: + {:ok, delete_test_suite_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, delete_test_suite_errors()} + def delete_test_suite(%Client{} = client, test_suite_id, input, options \\ []) do + url_path = "/testsuites/#{AWS.Util.encode_uri(test_suite_id)}" + headers = [] + query_params = [] + + meta = metadata() + + Request.request_rest( + client, + meta, + :delete, + url_path, + query_params, + headers, + input, + options, + 204 + ) + end + + @doc """ + Gets a test case. + """ + @spec get_test_case(map(), String.t(), String.t() | nil, list()) :: + {:ok, get_test_case_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, get_test_case_errors()} + def get_test_case(%Client{} = client, test_case_id, test_case_version \\ nil, options \\ []) do + url_path = "/testcases/#{AWS.Util.encode_uri(test_case_id)}" + headers = [] + query_params = [] + + query_params = + if !is_nil(test_case_version) do + [{"testCaseVersion", test_case_version} | query_params] + else + query_params + end + + meta = metadata() + + Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) + end + + @doc """ + Gets a test configuration. + """ + @spec get_test_configuration(map(), String.t(), String.t() | nil, list()) :: + {:ok, get_test_configuration_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, get_test_configuration_errors()} + def get_test_configuration( + %Client{} = client, + test_configuration_id, + test_configuration_version \\ nil, + options \\ [] + ) do + url_path = "/testconfigurations/#{AWS.Util.encode_uri(test_configuration_id)}" + headers = [] + query_params = [] + + query_params = + if !is_nil(test_configuration_version) do + [{"testConfigurationVersion", test_configuration_version} | query_params] + else + query_params + end + + meta = metadata() + + Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) + end + + @doc """ + Gets a test run step. + """ + @spec get_test_run_step( + map(), + String.t(), + String.t(), + String.t() | nil, + String.t() | nil, + list() + ) :: + {:ok, get_test_run_step_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, get_test_run_step_errors()} + def get_test_run_step( + %Client{} = client, + step_name, + test_run_id, + test_case_id \\ nil, + test_suite_id \\ nil, + options \\ [] + ) do + url_path = + "/testruns/#{AWS.Util.encode_uri(test_run_id)}/steps/#{AWS.Util.encode_uri(step_name)}" + + headers = [] + query_params = [] + + query_params = + if !is_nil(test_suite_id) do + [{"testSuiteId", test_suite_id} | query_params] + else + query_params + end + + query_params = + if !is_nil(test_case_id) do + [{"testCaseId", test_case_id} | query_params] + else + query_params + end + + meta = metadata() + + Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) + end + + @doc """ + Gets a test suite. + """ + @spec get_test_suite(map(), String.t(), String.t() | nil, list()) :: + {:ok, get_test_suite_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, get_test_suite_errors()} + def get_test_suite(%Client{} = client, test_suite_id, test_suite_version \\ nil, options \\ []) do + url_path = "/testsuites/#{AWS.Util.encode_uri(test_suite_id)}" + headers = [] + query_params = [] + + query_params = + if !is_nil(test_suite_version) do + [{"testSuiteVersion", test_suite_version} | query_params] + else + query_params + end + + meta = metadata() + + Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) + end + + @doc """ + Lists tags for a resource. + """ + @spec list_tags_for_resource(map(), String.t(), list()) :: + {:ok, list_tags_for_resource_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, list_tags_for_resource_errors()} + def list_tags_for_resource(%Client{} = client, resource_arn, options \\ []) do + url_path = "/tags/#{AWS.Util.encode_uri(resource_arn)}" + headers = [] + query_params = [] + + meta = metadata() + + Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) + end + + @doc """ + Lists test cases. + """ + @spec list_test_cases(map(), String.t() | nil, String.t() | nil, String.t() | nil, list()) :: + {:ok, list_test_cases_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, list_test_cases_errors()} + def list_test_cases( + %Client{} = client, + max_results \\ nil, + next_token \\ nil, + test_case_ids \\ nil, + options \\ [] + ) do + url_path = "/testcases" + headers = [] + query_params = [] + + query_params = + if !is_nil(test_case_ids) do + [{"testCaseIds", test_case_ids} | query_params] + else + query_params + end + + query_params = + if !is_nil(next_token) do + [{"nextToken", next_token} | query_params] + else + query_params + end + + query_params = + if !is_nil(max_results) do + [{"maxResults", max_results} | query_params] + else + query_params + end + + meta = metadata() + + Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) + end + + @doc """ + Lists test configurations. + """ + @spec list_test_configurations( + map(), + String.t() | nil, + String.t() | nil, + String.t() | nil, + list() + ) :: + {:ok, list_test_configurations_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, list_test_configurations_errors()} + def list_test_configurations( + %Client{} = client, + max_results \\ nil, + next_token \\ nil, + test_configuration_ids \\ nil, + options \\ [] + ) do + url_path = "/testconfigurations" + headers = [] + query_params = [] + + query_params = + if !is_nil(test_configuration_ids) do + [{"testConfigurationIds", test_configuration_ids} | query_params] + else + query_params + end + + query_params = + if !is_nil(next_token) do + [{"nextToken", next_token} | query_params] + else + query_params + end + + query_params = + if !is_nil(max_results) do + [{"maxResults", max_results} | query_params] + else + query_params + end + + meta = metadata() + + Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) + end + + @doc """ + Lists test run steps. + """ + @spec list_test_run_steps( + map(), + String.t(), + String.t() | nil, + String.t() | nil, + String.t() | nil, + String.t() | nil, + list() + ) :: + {:ok, list_test_run_steps_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, list_test_run_steps_errors()} + def list_test_run_steps( + %Client{} = client, + test_run_id, + max_results \\ nil, + next_token \\ nil, + test_case_id \\ nil, + test_suite_id \\ nil, + options \\ [] + ) do + url_path = "/testruns/#{AWS.Util.encode_uri(test_run_id)}/steps" + headers = [] + query_params = [] + + query_params = + if !is_nil(test_suite_id) do + [{"testSuiteId", test_suite_id} | query_params] + else + query_params + end + + query_params = + if !is_nil(test_case_id) do + [{"testCaseId", test_case_id} | query_params] + else + query_params + end + + query_params = + if !is_nil(next_token) do + [{"nextToken", next_token} | query_params] + else + query_params + end + + query_params = + if !is_nil(max_results) do + [{"maxResults", max_results} | query_params] + else + query_params + end + + meta = metadata() + + Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) + end + + @doc """ + Lists test run test cases. + """ + @spec list_test_run_test_cases(map(), String.t(), String.t() | nil, String.t() | nil, list()) :: + {:ok, list_test_run_test_cases_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, list_test_run_test_cases_errors()} + def list_test_run_test_cases( + %Client{} = client, + test_run_id, + max_results \\ nil, + next_token \\ nil, + options \\ [] + ) do + url_path = "/testruns/#{AWS.Util.encode_uri(test_run_id)}/testcases" + headers = [] + query_params = [] + + query_params = + if !is_nil(next_token) do + [{"nextToken", next_token} | query_params] + else + query_params + end + + query_params = + if !is_nil(max_results) do + [{"maxResults", max_results} | query_params] + else + query_params + end + + meta = metadata() + + Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) + end + + @doc """ + Lists test runs. + """ + @spec list_test_runs( + map(), + String.t() | nil, + String.t() | nil, + String.t() | nil, + String.t() | nil, + list() + ) :: + {:ok, list_test_runs_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, list_test_runs_errors()} + def list_test_runs( + %Client{} = client, + max_results \\ nil, + next_token \\ nil, + test_run_ids \\ nil, + test_suite_id \\ nil, + options \\ [] + ) do + url_path = "/testruns" + headers = [] + query_params = [] + + query_params = + if !is_nil(test_suite_id) do + [{"testSuiteId", test_suite_id} | query_params] + else + query_params + end + + query_params = + if !is_nil(test_run_ids) do + [{"testrunIds", test_run_ids} | query_params] + else + query_params + end + + query_params = + if !is_nil(next_token) do + [{"nextToken", next_token} | query_params] + else + query_params + end + + query_params = + if !is_nil(max_results) do + [{"maxResults", max_results} | query_params] + else + query_params + end + + meta = metadata() + + Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) + end + + @doc """ + Lists test suites. + """ + @spec list_test_suites(map(), String.t() | nil, String.t() | nil, String.t() | nil, list()) :: + {:ok, list_test_suites_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, list_test_suites_errors()} + def list_test_suites( + %Client{} = client, + max_results \\ nil, + next_token \\ nil, + test_suite_ids \\ nil, + options \\ [] + ) do + url_path = "/testsuites" + headers = [] + query_params = [] + + query_params = + if !is_nil(test_suite_ids) do + [{"testSuiteIds", test_suite_ids} | query_params] + else + query_params + end + + query_params = + if !is_nil(next_token) do + [{"nextToken", next_token} | query_params] + else + query_params + end + + query_params = + if !is_nil(max_results) do + [{"maxResults", max_results} | query_params] + else + query_params + end + + meta = metadata() + + Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) + end + + @doc """ + Starts a test run. + """ + @spec start_test_run(map(), start_test_run_request(), list()) :: + {:ok, start_test_run_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, start_test_run_errors()} + def start_test_run(%Client{} = client, input, options \\ []) do + url_path = "/testrun" + headers = [] + query_params = [] + + meta = metadata() + + Request.request_rest( + client, + meta, + :post, + url_path, + query_params, + headers, + input, + options, + 200 + ) + end + + @doc """ + Specifies tags of a resource. + """ + @spec tag_resource(map(), String.t(), tag_resource_request(), list()) :: + {:ok, tag_resource_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, tag_resource_errors()} + def tag_resource(%Client{} = client, resource_arn, input, options \\ []) do + url_path = "/tags/#{AWS.Util.encode_uri(resource_arn)}" + headers = [] + query_params = [] + + meta = metadata() + + Request.request_rest( + client, + meta, + :post, + url_path, + query_params, + headers, + input, + options, + 200 + ) + end + + @doc """ + Untags a resource. + """ + @spec untag_resource(map(), String.t(), untag_resource_request(), list()) :: + {:ok, untag_resource_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, untag_resource_errors()} + def untag_resource(%Client{} = client, resource_arn, input, options \\ []) do + url_path = "/tags/#{AWS.Util.encode_uri(resource_arn)}" + headers = [] + + {query_params, input} = + [ + {"tagKeys", "tagKeys"} + ] + |> Request.build_params(input) + + meta = metadata() + + Request.request_rest( + client, + meta, + :delete, + url_path, + query_params, + headers, + input, + options, + 200 + ) + end + + @doc """ + Updates a test case. + """ + @spec update_test_case(map(), String.t(), update_test_case_request(), list()) :: + {:ok, update_test_case_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, update_test_case_errors()} + def update_test_case(%Client{} = client, test_case_id, input, options \\ []) do + url_path = "/testcases/#{AWS.Util.encode_uri(test_case_id)}" + headers = [] + query_params = [] + + meta = metadata() + + Request.request_rest( + client, + meta, + :patch, + url_path, + query_params, + headers, + input, + options, + 200 + ) + end + + @doc """ + Updates a test configuration. + """ + @spec update_test_configuration(map(), String.t(), update_test_configuration_request(), list()) :: + {:ok, update_test_configuration_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, update_test_configuration_errors()} + def update_test_configuration(%Client{} = client, test_configuration_id, input, options \\ []) do + url_path = "/testconfigurations/#{AWS.Util.encode_uri(test_configuration_id)}" + headers = [] + query_params = [] + + meta = metadata() + + Request.request_rest( + client, + meta, + :patch, + url_path, + query_params, + headers, + input, + options, + 200 + ) + end + + @doc """ + Updates a test suite. + """ + @spec update_test_suite(map(), String.t(), update_test_suite_request(), list()) :: + {:ok, update_test_suite_response(), any()} + | {:error, {:unexpected_response, any()}} + | {:error, update_test_suite_errors()} + def update_test_suite(%Client{} = client, test_suite_id, input, options \\ []) do + url_path = "/testsuites/#{AWS.Util.encode_uri(test_suite_id)}" + headers = [] + query_params = [] + + meta = metadata() + + Request.request_rest( + client, + meta, + :patch, + url_path, + query_params, + headers, + input, + options, + 200 + ) + end +end diff --git a/lib/aws/generated/backup_storage.ex b/lib/aws/generated/backup_storage.ex deleted file mode 100644 index 42aa6922..00000000 --- a/lib/aws/generated/backup_storage.ex +++ /dev/null @@ -1,793 +0,0 @@ -# WARNING: DO NOT EDIT, AUTO-GENERATED CODE! -# See https://github.com/aws-beam/aws-codegen for more details. - -defmodule AWS.BackupStorage do - @moduledoc """ - The frontend service for Cryo Storage. - """ - - alias AWS.Client - alias AWS.Request - - @typedoc """ - - ## Example: - - access_denied_exception() :: %{ - "Message" => String.t() - } - - """ - @type access_denied_exception() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - backup_object() :: %{ - "ChunksCount" => float(), - "MetadataString" => String.t(), - "Name" => String.t(), - "ObjectChecksum" => String.t(), - "ObjectChecksumAlgorithm" => list(any()), - "ObjectToken" => String.t() - } - - """ - @type backup_object() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - chunk() :: %{ - "Checksum" => String.t(), - "ChecksumAlgorithm" => list(any()), - "ChunkToken" => String.t(), - "Index" => float(), - "Length" => float() - } - - """ - @type chunk() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - data_already_exists_exception() :: %{ - "Checksum" => String.t(), - "ChecksumAlgorithm" => String.t(), - "Message" => String.t() - } - - """ - @type data_already_exists_exception() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - delete_object_input() :: %{} - - """ - @type delete_object_input() :: %{} - - @typedoc """ - - ## Example: - - get_chunk_input() :: %{} - - """ - @type get_chunk_input() :: %{} - - @typedoc """ - - ## Example: - - get_chunk_output() :: %{ - "Checksum" => String.t(), - "ChecksumAlgorithm" => list(any()), - "Data" => binary(), - "Length" => float() - } - - """ - @type get_chunk_output() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - get_object_metadata_input() :: %{} - - """ - @type get_object_metadata_input() :: %{} - - @typedoc """ - - ## Example: - - get_object_metadata_output() :: %{ - "MetadataBlob" => binary(), - "MetadataBlobChecksum" => String.t(), - "MetadataBlobChecksumAlgorithm" => list(any()), - "MetadataBlobLength" => float(), - "MetadataString" => String.t() - } - - """ - @type get_object_metadata_output() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - illegal_argument_exception() :: %{ - "Message" => String.t() - } - - """ - @type illegal_argument_exception() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - kms_invalid_key_usage_exception() :: %{ - "Message" => String.t() - } - - """ - @type kms_invalid_key_usage_exception() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - list_chunks_input() :: %{ - optional("MaxResults") => integer(), - optional("NextToken") => String.t() - } - - """ - @type list_chunks_input() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - list_chunks_output() :: %{ - "ChunkList" => list(chunk()()), - "NextToken" => String.t() - } - - """ - @type list_chunks_output() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - list_objects_input() :: %{ - optional("CreatedAfter") => non_neg_integer(), - optional("CreatedBefore") => non_neg_integer(), - optional("MaxResults") => integer(), - optional("NextToken") => String.t(), - optional("StartingObjectName") => String.t(), - optional("StartingObjectPrefix") => String.t() - } - - """ - @type list_objects_input() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - list_objects_output() :: %{ - "NextToken" => String.t(), - "ObjectList" => list(backup_object()()) - } - - """ - @type list_objects_output() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - not_readable_input_stream_exception() :: %{ - "Message" => String.t() - } - - """ - @type not_readable_input_stream_exception() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - notify_object_complete_input() :: %{ - optional("MetadataBlob") => binary(), - optional("MetadataBlobChecksum") => String.t(), - optional("MetadataBlobChecksumAlgorithm") => list(any()), - optional("MetadataBlobLength") => float(), - optional("MetadataString") => String.t(), - required("ObjectChecksum") => String.t(), - required("ObjectChecksumAlgorithm") => list(any()) - } - - """ - @type notify_object_complete_input() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - notify_object_complete_output() :: %{ - "ObjectChecksum" => String.t(), - "ObjectChecksumAlgorithm" => list(any()) - } - - """ - @type notify_object_complete_output() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - put_chunk_input() :: %{ - required("Checksum") => String.t(), - required("ChecksumAlgorithm") => list(any()), - required("Data") => binary(), - required("Length") => float() - } - - """ - @type put_chunk_input() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - put_chunk_output() :: %{ - "ChunkChecksum" => String.t(), - "ChunkChecksumAlgorithm" => list(any()) - } - - """ - @type put_chunk_output() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - put_object_input() :: %{ - optional("InlineChunk") => binary(), - optional("InlineChunkChecksum") => String.t(), - optional("InlineChunkChecksumAlgorithm") => String.t(), - optional("InlineChunkLength") => float(), - optional("MetadataString") => String.t(), - optional("ObjectChecksum") => String.t(), - optional("ObjectChecksumAlgorithm") => list(any()), - optional("ThrowOnDuplicate") => boolean() - } - - """ - @type put_object_input() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - put_object_output() :: %{ - "InlineChunkChecksum" => String.t(), - "InlineChunkChecksumAlgorithm" => list(any()), - "ObjectChecksum" => String.t(), - "ObjectChecksumAlgorithm" => list(any()) - } - - """ - @type put_object_output() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - resource_not_found_exception() :: %{ - "Message" => String.t() - } - - """ - @type resource_not_found_exception() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - retryable_exception() :: %{ - "Message" => String.t() - } - - """ - @type retryable_exception() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - service_internal_exception() :: %{ - "Message" => String.t() - } - - """ - @type service_internal_exception() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - service_unavailable_exception() :: %{ - "Message" => String.t() - } - - """ - @type service_unavailable_exception() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - start_object_input() :: %{ - optional("ThrowOnDuplicate") => boolean() - } - - """ - @type start_object_input() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - start_object_output() :: %{ - "UploadId" => String.t() - } - - """ - @type start_object_output() :: %{String.t() => any()} - - @typedoc """ - - ## Example: - - throttling_exception() :: %{ - "Message" => String.t() - } - - """ - @type throttling_exception() :: %{String.t() => any()} - - @type delete_object_errors() :: - throttling_exception() - | service_unavailable_exception() - | service_internal_exception() - | retryable_exception() - | resource_not_found_exception() - | illegal_argument_exception() - | access_denied_exception() - - @type get_chunk_errors() :: - throttling_exception() - | service_internal_exception() - | retryable_exception() - | resource_not_found_exception() - | kms_invalid_key_usage_exception() - | illegal_argument_exception() - | access_denied_exception() - - @type get_object_metadata_errors() :: - throttling_exception() - | service_unavailable_exception() - | service_internal_exception() - | retryable_exception() - | resource_not_found_exception() - | kms_invalid_key_usage_exception() - | illegal_argument_exception() - | access_denied_exception() - - @type list_chunks_errors() :: - service_unavailable_exception() - | service_internal_exception() - | retryable_exception() - | resource_not_found_exception() - | illegal_argument_exception() - | access_denied_exception() - - @type list_objects_errors() :: - throttling_exception() - | service_unavailable_exception() - | service_internal_exception() - | retryable_exception() - | resource_not_found_exception() - | kms_invalid_key_usage_exception() - | illegal_argument_exception() - | access_denied_exception() - - @type notify_object_complete_errors() :: - throttling_exception() - | service_unavailable_exception() - | service_internal_exception() - | retryable_exception() - | not_readable_input_stream_exception() - | kms_invalid_key_usage_exception() - | illegal_argument_exception() - | access_denied_exception() - - @type put_chunk_errors() :: - throttling_exception() - | service_unavailable_exception() - | service_internal_exception() - | retryable_exception() - | not_readable_input_stream_exception() - | kms_invalid_key_usage_exception() - | illegal_argument_exception() - | access_denied_exception() - - @type put_object_errors() :: - throttling_exception() - | service_unavailable_exception() - | service_internal_exception() - | retryable_exception() - | not_readable_input_stream_exception() - | kms_invalid_key_usage_exception() - | illegal_argument_exception() - | access_denied_exception() - - @type start_object_errors() :: - throttling_exception() - | service_unavailable_exception() - | service_internal_exception() - | retryable_exception() - | resource_not_found_exception() - | illegal_argument_exception() - | data_already_exists_exception() - | access_denied_exception() - - def metadata do - %{ - api_version: "2018-04-10", - content_type: "application/x-amz-json-1.1", - credential_scope: nil, - endpoint_prefix: "backupstorage", - global?: false, - hostname: nil, - protocol: "rest-json", - service_id: "BackupStorage", - signature_version: "v4", - signing_name: "backup-storage", - target_prefix: nil - } - end - - @doc """ - Delete Object from the incremental base Backup. - """ - @spec delete_object(map(), String.t(), String.t(), delete_object_input(), list()) :: - {:ok, nil, any()} - | {:error, {:unexpected_response, any()}} - | {:error, delete_object_errors()} - def delete_object(%Client{} = client, backup_job_id, object_name, input, options \\ []) do - url_path = - "/backup-jobs/#{AWS.Util.encode_uri(backup_job_id)}/object/#{AWS.Util.encode_uri(object_name)}" - - headers = [] - query_params = [] - - meta = metadata() - - Request.request_rest( - client, - meta, - :delete, - url_path, - query_params, - headers, - input, - options, - 200 - ) - end - - @doc """ - Gets the specified object's chunk. - """ - @spec get_chunk(map(), String.t(), String.t(), list()) :: - {:ok, get_chunk_output(), any()} - | {:error, {:unexpected_response, any()}} - | {:error, get_chunk_errors()} - def get_chunk(%Client{} = client, chunk_token, storage_job_id, options \\ []) do - url_path = - "/restore-jobs/#{AWS.Util.encode_uri(storage_job_id)}/chunk/#{AWS.Util.encode_uri(chunk_token)}" - - headers = [] - query_params = [] - - options = - Keyword.put( - options, - :response_header_parameters, - [ - {"x-amz-checksum", "Checksum"}, - {"x-amz-checksum-algorithm", "ChecksumAlgorithm"}, - {"x-amz-data-length", "Length"} - ] - ) - - meta = metadata() - - Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) - end - - @doc """ - Get metadata associated with an Object. - """ - @spec get_object_metadata(map(), String.t(), String.t(), list()) :: - {:ok, get_object_metadata_output(), any()} - | {:error, {:unexpected_response, any()}} - | {:error, get_object_metadata_errors()} - def get_object_metadata(%Client{} = client, object_token, storage_job_id, options \\ []) do - url_path = - "/restore-jobs/#{AWS.Util.encode_uri(storage_job_id)}/object/#{AWS.Util.encode_uri(object_token)}/metadata" - - headers = [] - query_params = [] - - options = - Keyword.put( - options, - :response_header_parameters, - [ - {"x-amz-checksum", "MetadataBlobChecksum"}, - {"x-amz-checksum-algorithm", "MetadataBlobChecksumAlgorithm"}, - {"x-amz-data-length", "MetadataBlobLength"}, - {"x-amz-metadata-string", "MetadataString"} - ] - ) - - meta = metadata() - - Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) - end - - @doc """ - List chunks in a given Object - """ - @spec list_chunks(map(), String.t(), String.t(), String.t() | nil, String.t() | nil, list()) :: - {:ok, list_chunks_output(), any()} - | {:error, {:unexpected_response, any()}} - | {:error, list_chunks_errors()} - def list_chunks( - %Client{} = client, - object_token, - storage_job_id, - max_results \\ nil, - next_token \\ nil, - options \\ [] - ) do - url_path = - "/restore-jobs/#{AWS.Util.encode_uri(storage_job_id)}/chunks/#{AWS.Util.encode_uri(object_token)}/list" - - headers = [] - query_params = [] - - query_params = - if !is_nil(next_token) do - [{"next-token", next_token} | query_params] - else - query_params - end - - query_params = - if !is_nil(max_results) do - [{"max-results", max_results} | query_params] - else - query_params - end - - meta = metadata() - - Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) - end - - @doc """ - List all Objects in a given Backup. - """ - @spec list_objects( - map(), - String.t(), - String.t() | nil, - String.t() | nil, - String.t() | nil, - String.t() | nil, - String.t() | nil, - String.t() | nil, - list() - ) :: - {:ok, list_objects_output(), any()} - | {:error, {:unexpected_response, any()}} - | {:error, list_objects_errors()} - def list_objects( - %Client{} = client, - storage_job_id, - created_after \\ nil, - created_before \\ nil, - max_results \\ nil, - next_token \\ nil, - starting_object_name \\ nil, - starting_object_prefix \\ nil, - options \\ [] - ) do - url_path = "/restore-jobs/#{AWS.Util.encode_uri(storage_job_id)}/objects/list" - headers = [] - query_params = [] - - query_params = - if !is_nil(starting_object_prefix) do - [{"starting-object-prefix", starting_object_prefix} | query_params] - else - query_params - end - - query_params = - if !is_nil(starting_object_name) do - [{"starting-object-name", starting_object_name} | query_params] - else - query_params - end - - query_params = - if !is_nil(next_token) do - [{"next-token", next_token} | query_params] - else - query_params - end - - query_params = - if !is_nil(max_results) do - [{"max-results", max_results} | query_params] - else - query_params - end - - query_params = - if !is_nil(created_before) do - [{"created-before", created_before} | query_params] - else - query_params - end - - query_params = - if !is_nil(created_after) do - [{"created-after", created_after} | query_params] - else - query_params - end - - meta = metadata() - - Request.request_rest(client, meta, :get, url_path, query_params, headers, nil, options, 200) - end - - @doc """ - Complete upload - """ - @spec notify_object_complete( - map(), - String.t(), - String.t(), - notify_object_complete_input(), - list() - ) :: - {:ok, notify_object_complete_output(), any()} - | {:error, {:unexpected_response, any()}} - | {:error, notify_object_complete_errors()} - def notify_object_complete(%Client{} = client, backup_job_id, upload_id, input, options \\ []) do - url_path = - "/backup-jobs/#{AWS.Util.encode_uri(backup_job_id)}/object/#{AWS.Util.encode_uri(upload_id)}/complete" - - headers = [] - - {query_params, input} = - [ - {"MetadataBlobChecksum", "metadata-checksum"}, - {"MetadataBlobChecksumAlgorithm", "metadata-checksum-algorithm"}, - {"MetadataBlobLength", "metadata-blob-length"}, - {"MetadataString", "metadata-string"}, - {"ObjectChecksum", "checksum"}, - {"ObjectChecksumAlgorithm", "checksum-algorithm"} - ] - |> Request.build_params(input) - - meta = metadata() - - Request.request_rest(client, meta, :put, url_path, query_params, headers, input, options, 200) - end - - @doc """ - Upload chunk. - """ - @spec put_chunk(map(), String.t(), String.t(), String.t(), put_chunk_input(), list()) :: - {:ok, put_chunk_output(), any()} - | {:error, {:unexpected_response, any()}} - | {:error, put_chunk_errors()} - def put_chunk(%Client{} = client, backup_job_id, chunk_index, upload_id, input, options \\ []) do - url_path = - "/backup-jobs/#{AWS.Util.encode_uri(backup_job_id)}/chunk/#{AWS.Util.encode_uri(upload_id)}/#{AWS.Util.encode_uri(chunk_index)}" - - headers = [] - - {query_params, input} = - [ - {"Checksum", "checksum"}, - {"ChecksumAlgorithm", "checksum-algorithm"}, - {"Length", "length"} - ] - |> Request.build_params(input) - - meta = metadata() - - Request.request_rest(client, meta, :put, url_path, query_params, headers, input, options, 200) - end - - @doc """ - Upload object that can store object metadata String and data blob in single API - call using inline chunk field. - """ - @spec put_object(map(), String.t(), String.t(), put_object_input(), list()) :: - {:ok, put_object_output(), any()} - | {:error, {:unexpected_response, any()}} - | {:error, put_object_errors()} - def put_object(%Client{} = client, backup_job_id, object_name, input, options \\ []) do - url_path = - "/backup-jobs/#{AWS.Util.encode_uri(backup_job_id)}/object/#{AWS.Util.encode_uri(object_name)}/put-object" - - headers = [] - - {query_params, input} = - [ - {"InlineChunkChecksum", "checksum"}, - {"InlineChunkChecksumAlgorithm", "checksum-algorithm"}, - {"InlineChunkLength", "length"}, - {"MetadataString", "metadata-string"}, - {"ObjectChecksum", "object-checksum"}, - {"ObjectChecksumAlgorithm", "object-checksum-algorithm"}, - {"ThrowOnDuplicate", "throwOnDuplicate"} - ] - |> Request.build_params(input) - - meta = metadata() - - Request.request_rest(client, meta, :put, url_path, query_params, headers, input, options, 200) - end - - @doc """ - Start upload containing one or many chunks. - """ - @spec start_object(map(), String.t(), String.t(), start_object_input(), list()) :: - {:ok, start_object_output(), any()} - | {:error, {:unexpected_response, any()}} - | {:error, start_object_errors()} - def start_object(%Client{} = client, backup_job_id, object_name, input, options \\ []) do - url_path = - "/backup-jobs/#{AWS.Util.encode_uri(backup_job_id)}/object/#{AWS.Util.encode_uri(object_name)}" - - headers = [] - query_params = [] - - meta = metadata() - - Request.request_rest(client, meta, :put, url_path, query_params, headers, input, options, 200) - end -end diff --git a/lib/aws/generated/ec2.ex b/lib/aws/generated/ec2.ex index e0a0d449..1b488f4f 100644 --- a/lib/aws/generated/ec2.ex +++ b/lib/aws/generated/ec2.ex @@ -2540,6 +2540,18 @@ defmodule AWS.EC2 do @typedoc """ + ## Example: + + describe_traffic_mirror_filter_rules_result() :: %{ + "NextToken" => String.t(), + "TrafficMirrorFilterRules" => list(traffic_mirror_filter_rule()()) + } + + """ + @type describe_traffic_mirror_filter_rules_result() :: %{String.t() => any()} + + @typedoc """ + ## Example: accept_vpc_peering_connection_result() :: %{ @@ -7338,6 +7350,7 @@ defmodule AWS.EC2 do "RuleNumber" => integer(), "SourceCidrBlock" => String.t(), "SourcePortRange" => traffic_mirror_port_range(), + "Tags" => list(tag()()), "TrafficDirection" => list(any()), "TrafficMirrorFilterId" => String.t(), "TrafficMirrorFilterRuleId" => String.t() @@ -9937,6 +9950,7 @@ defmodule AWS.EC2 do optional("DryRun") => boolean(), optional("Protocol") => integer(), optional("SourcePortRange") => traffic_mirror_port_range_request(), + optional("TagSpecifications") => list(tag_specification()()), required("DestinationCidrBlock") => String.t(), required("RuleAction") => list(any()), required("RuleNumber") => integer(), @@ -22095,6 +22109,22 @@ defmodule AWS.EC2 do @typedoc """ + ## Example: + + describe_traffic_mirror_filter_rules_request() :: %{ + optional("DryRun") => boolean(), + optional("Filters") => list(filter()()), + optional("MaxResults") => integer(), + optional("NextToken") => String.t(), + optional("TrafficMirrorFilterId") => String.t(), + optional("TrafficMirrorFilterRuleIds") => list(String.t()()) + } + + """ + @type describe_traffic_mirror_filter_rules_request() :: %{String.t() => any()} + + @typedoc """ + ## Example: inference_device_info() :: %{ @@ -29521,8 +29551,9 @@ defmodule AWS.EC2 do A Traffic Mirror filter is a set of rules that defines the traffic to mirror. By default, no traffic is mirrored. To mirror traffic, use - [CreateTrafficMirrorFilterRule](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTrafficMirrorFilterRule.htm) to add Traffic Mirror rules to the filter. The rules you - add define what traffic gets mirrored. You can also use + [CreateTrafficMirrorFilterRule](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTrafficMirrorFilterRule.htm) to add Traffic Mirror rules to the filter. The rules you add define what traffic + gets mirrored. + You can also use [ModifyTrafficMirrorFilterNetworkServices](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyTrafficMirrorFilterNetworkServices.html) to mirror supported network services. """ @@ -33954,6 +33985,22 @@ defmodule AWS.EC2 do Request.request_post(client, meta, "DescribeTags", input, options) end + @doc """ + Describe traffic mirror filters that determine the traffic that is mirrored. + """ + @spec describe_traffic_mirror_filter_rules( + map(), + describe_traffic_mirror_filter_rules_request(), + list() + ) :: + {:ok, describe_traffic_mirror_filter_rules_result(), any()} + | {:error, {:unexpected_response, any()}} + def describe_traffic_mirror_filter_rules(%Client{} = client, input, options \\ []) do + meta = metadata() + + Request.request_post(client, meta, "DescribeTrafficMirrorFilterRules", input, options) + end + @doc """ Describes one or more Traffic Mirror filters. """ diff --git a/lib/aws/generated/osis.ex b/lib/aws/generated/osis.ex index 64d08b7d..8e28c056 100644 --- a/lib/aws/generated/osis.ex +++ b/lib/aws/generated/osis.ex @@ -137,6 +137,7 @@ defmodule AWS.OSIS do "Status" => list(any()), "StatusReason" => pipeline_status_reason(), "Tags" => list(tag()()), + "VpcEndpointService" => String.t(), "VpcEndpoints" => list(vpc_endpoint()()) } @@ -599,7 +600,8 @@ defmodule AWS.OSIS do vpc_options() :: %{ "SecurityGroupIds" => list(String.t()()), "SubnetIds" => list(String.t()()), - "VpcAttachmentOptions" => vpc_attachment_options() + "VpcAttachmentOptions" => vpc_attachment_options(), + "VpcEndpointManagement" => list(any()) } """ diff --git a/lib/aws/generated/redshift.ex b/lib/aws/generated/redshift.ex index 97fcd882..6501f6af 100644 --- a/lib/aws/generated/redshift.ex +++ b/lib/aws/generated/redshift.ex @@ -8978,24 +8978,12 @@ defmodule AWS.Redshift do * You can only resize clusters of the following types: - * - dc1.large (if your cluster is in a VPC) - - * - dc1.8xlarge (if your cluster is in a VPC) - * dc2.large * dc2.8xlarge - * - ds2.xlarge - - * - ds2.8xlarge - * ra3.xlplus diff --git a/lib/aws/generated/secrets_manager.ex b/lib/aws/generated/secrets_manager.ex index 7d21bc94..418e7506 100644 --- a/lib/aws/generated/secrets_manager.ex +++ b/lib/aws/generated/secrets_manager.ex @@ -553,6 +553,7 @@ defmodule AWS.SecretsManager do put_secret_value_request() :: %{ optional("ClientRequestToken") => String.t(), + optional("RotationToken") => String.t(), optional("SecretBinary") => binary(), optional("SecretString") => String.t(), optional("VersionStages") => list(String.t()()), @@ -1610,9 +1611,9 @@ defmodule AWS.SecretsManager do only create new ones. Secrets Manager generates a CloudTrail log entry when you call this action. Do - not include sensitive information in request parameters except `SecretBinary` or - `SecretString` because it might be logged. For more information, see [Logging Secrets Manager events with - CloudTrail](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieve-ct-entries.html). + not include sensitive information in request parameters except `SecretBinary`, + `SecretString`, or `RotationToken` because it might be logged. For more + information, see [Logging Secrets Manager events with CloudTrail](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieve-ct-entries.html). ## Required permissions: `secretsmanager:PutSecretValue`. diff --git a/lib/aws/generated/sesv2.ex b/lib/aws/generated/sesv2.ex index 231834ad..8d0ed5e5 100644 --- a/lib/aws/generated/sesv2.ex +++ b/lib/aws/generated/sesv2.ex @@ -933,6 +933,7 @@ defmodule AWS.SESv2 do event_destination_definition() :: %{ "CloudWatchDestination" => cloud_watch_destination(), "Enabled" => boolean(), + "EventBridgeDestination" => event_bridge_destination(), "KinesisFirehoseDestination" => kinesis_firehose_destination(), "MatchingEventTypes" => list(list(any())()), "PinpointDestination" => pinpoint_destination(), @@ -1447,6 +1448,7 @@ defmodule AWS.SESv2 do event_destination() :: %{ "CloudWatchDestination" => cloud_watch_destination(), "Enabled" => boolean(), + "EventBridgeDestination" => event_bridge_destination(), "KinesisFirehoseDestination" => kinesis_firehose_destination(), "MatchingEventTypes" => list(list(any())()), "Name" => String.t(), @@ -2139,6 +2141,17 @@ defmodule AWS.SESv2 do @typedoc """ + ## Example: + + event_bridge_destination() :: %{ + "EventBusArn" => String.t() + } + + """ + @type event_bridge_destination() :: %{String.t() => any()} + + @typedoc """ + ## Example: send_custom_verification_email_request() :: %{ @@ -3888,11 +3901,9 @@ defmodule AWS.SESv2 do *Events* include message sends, deliveries, opens, clicks, bounces, and complaints. *Event destinations* are places that you can send information about these events - to. For example, you can send event data to Amazon SNS to receive notifications - when you - receive bounces or complaints, or you can use Amazon Kinesis Data Firehose to - stream data to Amazon S3 for long-term - storage. + to. For example, you can send event data to Amazon EventBridge and associate a + rule to send the event + to the specified target. A single configuration set can include more than one event destination. """ @@ -4356,10 +4367,8 @@ defmodule AWS.SESv2 do *Events* include message sends, deliveries, opens, clicks, bounces, and complaints. *Event destinations* are places that you can send information about these events to. For example, you can send event data to - Amazon SNS to - receive notifications when you receive bounces or complaints, or you can use - Amazon Kinesis Data Firehose to - stream data to Amazon S3 for long-term storage. + Amazon EventBridge and + associate a rule to send the event to the specified target. """ @spec delete_configuration_set_event_destination( map(), @@ -4753,10 +4762,8 @@ defmodule AWS.SESv2 do *Events* include message sends, deliveries, opens, clicks, bounces, and complaints. *Event destinations* are places that you can send information about these events to. For example, you can send event data to - Amazon SNS to - receive notifications when you receive bounces or complaints, or you can use - Amazon Kinesis Data Firehose to - stream data to Amazon S3 for long-term storage. + Amazon EventBridge and + associate a rule to send the event to the specified target. """ @spec get_configuration_set_event_destinations(map(), String.t(), list()) :: {:ok, get_configuration_set_event_destinations_response(), any()} @@ -6573,10 +6580,8 @@ defmodule AWS.SESv2 do *Events* include message sends, deliveries, opens, clicks, bounces, and complaints. *Event destinations* are places that you can send information about these events to. For example, you can send event data to - Amazon SNS to - receive notifications when you receive bounces or complaints, or you can use - Amazon Kinesis Data Firehose to - stream data to Amazon S3 for long-term storage. + Amazon EventBridge and + associate a rule to send the event to the specified target. """ @spec update_configuration_set_event_destination( map(),