Merge branch 'main' into path-saparator

Author: pulimsr

VERSION

@@ -1 +1 @@
-1.11.687
+1.11.688

generated/src/aws-cpp-sdk-batch/include/aws/batch/model/ComputeResource.h

@@ -194,7 +194,7 @@ class ComputeResource {
    * <code>default_x86_64</code> to choose x86 based instance types (from the
    * <code>m6i</code>, <code>c6i</code>, <code>r6i</code>, and <code>c7i</code>
    * instance families) that matches the resource demands of the job queue.</p> </li>
-   * <li> <p> <code>default_arm64</code> to choose x86 based instance types (from the
+   * <li> <p> <code>default_arm64</code> to choose ARM based instance types (from the
    * <code>m6g</code>, <code>c6g</code>, <code>r6g</code>, and <code>c7g</code>
    * instance families) that matches the resource demands of the job queue.</p> </li>
    * </ul>  <p>Starting on 11/01/2025 the behavior of <code>optimal</code> is

generated/src/aws-cpp-sdk-batch/include/aws/batch/model/Ec2Configuration.h

@@ -75,38 +75,37 @@ class Ec2Configuration {
    * instance types.</p>  </dd> </dl> </dd> <dt>EKS</dt> <dd> <p>If the
    * <code>imageIdOverride</code> parameter isn't specified, then a recent <a
    * href="https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html">Amazon
-   * EKS-optimized Amazon Linux AMI</a> (<code>EKS_AL2</code>) is used. If a new
-   * image type is specified in an update, but neither an <code>imageId</code> nor a
-   * <code>imageIdOverride</code> parameter is specified, then the latest Amazon EKS
-   * optimized AMI for that image type that Batch supports is used.</p>
-   * <p>Starting end of October 2025 Amazon EKS optimized Amazon Linux 2023 AMIs will
-   * be the default on Batch for EKS versions prior to 1.33. Starting from Kubernetes
-   * version 1.33, EKS optimized Amazon Linux 2023 AMIs will be the default when it
-   * becomes supported on Batch.</p> <p>Amazon Web Services will end support for
-   * Amazon EKS AL2-optimized and AL2-accelerated AMIs, starting 11/26/25. You can
-   * continue using Batch-provided Amazon EKS optimized Amazon Linux 2 AMIs on your
-   * Amazon EKS compute environments beyond the 11/26/25 end-of-support date, these
-   * compute environments will no longer receive any new software updates, security
-   * patches, or bug fixes from Amazon Web Services. For more information on
-   * upgrading from AL2 to AL2023, see <a
+   * EKS-optimized Amazon Linux 2023 AMI</a> (<code>EKS_AL2023</code>) is used. If a
+   * new image type is specified in an update, but neither an <code>imageId</code>
+   * nor a <code>imageIdOverride</code> parameter is specified, then the latest
+   * Amazon EKS optimized AMI for that image type that Batch supports is used.</p>
+   *  <p>Amazon Linux 2023 AMIs are the default on Batch for Amazon
+   * EKS.</p> <p>Amazon Web Services will end support for Amazon EKS AL2-optimized
+   * and AL2-accelerated AMIs, starting 11/26/25. You can continue using
+   * Batch-provided Amazon EKS optimized Amazon Linux 2 AMIs on your Amazon EKS
+   * compute environments beyond the 11/26/25 end-of-support date, these compute
+   * environments will no longer receive any new software updates, security patches,
+   * or bug fixes from Amazon Web Services. For more information on upgrading from
+   * AL2 to AL2023, see <a
    * href="https://docs.aws.amazon.com/batch/latest/userguide/eks-migration-2023.html">How
    * to upgrade from EKS AL2 to EKS AL2023</a> in the <i>Batch User Guide</i>.</p>
    *  <dl> <dt>EKS_AL2</dt> <dd> <p> <a
    * href="https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html">Amazon
-   * Linux 2</a>: Default for all non-GPU instance families.</p> </dd>
+   * Linux 2</a>: Used for non-GPU instance families.</p> </dd>
    * <dt>EKS_AL2_NVIDIA</dt> <dd> <p> <a
    * href="https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html">Amazon
-   * Linux 2 (accelerated)</a>: Default for all GPU instance families (for example,
+   * Linux 2 (accelerated)</a>: Used for GPU instance families (for example,
    * <code>P4</code> and <code>G4</code>) and can be used for all non Amazon Web
    * Services Graviton-based instance types.</p> </dd> <dt>EKS_AL2023</dt> <dd> <p>
    * <a
    * href="https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html">Amazon
-   * Linux 2023</a>: Batch supports Amazon Linux 2023.</p>  <p>Amazon Linux
-   * 2023 does not support <code>A1</code> instances.</p>  </dd>
+   * Linux 2023</a>: Default for non-GPU instance families.</p>  <p>Amazon
+   * Linux 2023 does not support <code>A1</code> instances.</p>  </dd>
    * <dt>EKS_AL2023_NVIDIA</dt> <dd> <p> <a
    * href="https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html">Amazon
-   * Linux 2023 (accelerated)</a>: GPU instance families and can be used for all non
-   * Amazon Web Services Graviton-based instance types.</p> </dd> </dl> </dd> </dl>
+   * Linux 2023 (accelerated)</a>: Default for GPU instance families and can be used
+   * for all non Amazon Web Services Graviton-based instance types.</p> </dd> </dl>
+   * </dd> </dl>
    */
   inline const Aws::String& GetImageType() const { return m_imageType; }
   inline bool ImageTypeHasBeenSet() const { return m_imageTypeHasBeenSet; }

generated/src/aws-cpp-sdk-bedrock-data-automation/include/aws/bedrock-data-automation/model/AudioGenerativeOutputLanguage.h

@@ -0,0 +1,22 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/bedrock-data-automation/BedrockDataAutomation_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws {
+namespace BedrockDataAutomation {
+namespace Model {
+enum class AudioGenerativeOutputLanguage { NOT_SET, DEFAULT, EN };
+
+namespace AudioGenerativeOutputLanguageMapper {
+AWS_BEDROCKDATAAUTOMATION_API AudioGenerativeOutputLanguage GetAudioGenerativeOutputLanguageForName(const Aws::String& name);
+
+AWS_BEDROCKDATAAUTOMATION_API Aws::String GetNameForAudioGenerativeOutputLanguage(AudioGenerativeOutputLanguage value);
+}  // namespace AudioGenerativeOutputLanguageMapper
+}  // namespace Model
+}  // namespace BedrockDataAutomation
+}  // namespace Aws

generated/src/aws-cpp-sdk-bedrock-data-automation/include/aws/bedrock-data-automation/model/AudioLanguageConfiguration.h

@@ -0,0 +1,100 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/bedrock-data-automation/BedrockDataAutomation_EXPORTS.h>
+#include <aws/bedrock-data-automation/model/AudioGenerativeOutputLanguage.h>
+#include <aws/bedrock-data-automation/model/Language.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+
+#include <utility>
+
+namespace Aws {
+namespace Utils {
+namespace Json {
+class JsonValue;
+class JsonView;
+}  // namespace Json
+}  // namespace Utils
+namespace BedrockDataAutomation {
+namespace Model {
+
+/**
+ * <p>Optional configuration for audio language settings</p><p><h3>See Also:</h3>
+ * <a
+ * href="http://docs.aws.amazon.com/goto/WebAPI/bedrock-data-automation-2023-07-26/AudioLanguageConfiguration">AWS
+ * API Reference</a></p>
+ */
+class AudioLanguageConfiguration {
+ public:
+  AWS_BEDROCKDATAAUTOMATION_API AudioLanguageConfiguration() = default;
+  AWS_BEDROCKDATAAUTOMATION_API AudioLanguageConfiguration(Aws::Utils::Json::JsonView jsonValue);
+  AWS_BEDROCKDATAAUTOMATION_API AudioLanguageConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
+  AWS_BEDROCKDATAAUTOMATION_API Aws::Utils::Json::JsonValue Jsonize() const;
+
+  ///@{
+
+  inline const Aws::Vector<Language>& GetInputLanguages() const { return m_inputLanguages; }
+  inline bool InputLanguagesHasBeenSet() const { return m_inputLanguagesHasBeenSet; }
+  template <typename InputLanguagesT = Aws::Vector<Language>>
+  void SetInputLanguages(InputLanguagesT&& value) {
+    m_inputLanguagesHasBeenSet = true;
+    m_inputLanguages = std::forward<InputLanguagesT>(value);
+  }
+  template <typename InputLanguagesT = Aws::Vector<Language>>
+  AudioLanguageConfiguration& WithInputLanguages(InputLanguagesT&& value) {
+    SetInputLanguages(std::forward<InputLanguagesT>(value));
+    return *this;
+  }
+  inline AudioLanguageConfiguration& AddInputLanguages(Language value) {
+    m_inputLanguagesHasBeenSet = true;
+    m_inputLanguages.push_back(value);
+    return *this;
+  }
+  ///@}
+
+  ///@{
+
+  inline AudioGenerativeOutputLanguage GetGenerativeOutputLanguage() const { return m_generativeOutputLanguage; }
+  inline bool GenerativeOutputLanguageHasBeenSet() const { return m_generativeOutputLanguageHasBeenSet; }
+  inline void SetGenerativeOutputLanguage(AudioGenerativeOutputLanguage value) {
+    m_generativeOutputLanguageHasBeenSet = true;
+    m_generativeOutputLanguage = value;
+  }
+  inline AudioLanguageConfiguration& WithGenerativeOutputLanguage(AudioGenerativeOutputLanguage value) {
+    SetGenerativeOutputLanguage(value);
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p>Enable multiple language identification in audio</p>
+   */
+  inline bool GetIdentifyMultipleLanguages() const { return m_identifyMultipleLanguages; }
+  inline bool IdentifyMultipleLanguagesHasBeenSet() const { return m_identifyMultipleLanguagesHasBeenSet; }
+  inline void SetIdentifyMultipleLanguages(bool value) {
+    m_identifyMultipleLanguagesHasBeenSet = true;
+    m_identifyMultipleLanguages = value;
+  }
+  inline AudioLanguageConfiguration& WithIdentifyMultipleLanguages(bool value) {
+    SetIdentifyMultipleLanguages(value);
+    return *this;
+  }
+  ///@}
+ private:
+  Aws::Vector<Language> m_inputLanguages;
+  bool m_inputLanguagesHasBeenSet = false;
+
+  AudioGenerativeOutputLanguage m_generativeOutputLanguage{AudioGenerativeOutputLanguage::NOT_SET};
+  bool m_generativeOutputLanguageHasBeenSet = false;
+
+  bool m_identifyMultipleLanguages{false};
+  bool m_identifyMultipleLanguagesHasBeenSet = false;
+};
+
+}  // namespace Model
+}  // namespace BedrockDataAutomation
+}  // namespace Aws

generated/src/aws-cpp-sdk-bedrock-data-automation/include/aws/bedrock-data-automation/model/AudioOverrideConfiguration.h

@@ -5,6 +5,7 @@
 
 #pragma once
 #include <aws/bedrock-data-automation/BedrockDataAutomation_EXPORTS.h>
+#include <aws/bedrock-data-automation/model/AudioLanguageConfiguration.h>
 #include <aws/bedrock-data-automation/model/ModalityProcessingConfiguration.h>
 
 #include <utility>
@@ -46,9 +47,28 @@ class AudioOverrideConfiguration {
     return *this;
   }
   ///@}
+
+  ///@{
+
+  inline const AudioLanguageConfiguration& GetLanguageConfiguration() const { return m_languageConfiguration; }
+  inline bool LanguageConfigurationHasBeenSet() const { return m_languageConfigurationHasBeenSet; }
+  template <typename LanguageConfigurationT = AudioLanguageConfiguration>
+  void SetLanguageConfiguration(LanguageConfigurationT&& value) {
+    m_languageConfigurationHasBeenSet = true;
+    m_languageConfiguration = std::forward<LanguageConfigurationT>(value);
+  }
+  template <typename LanguageConfigurationT = AudioLanguageConfiguration>
+  AudioOverrideConfiguration& WithLanguageConfiguration(LanguageConfigurationT&& value) {
+    SetLanguageConfiguration(std::forward<LanguageConfigurationT>(value));
+    return *this;
+  }
+  ///@}
  private:
   ModalityProcessingConfiguration m_modalityProcessing;
   bool m_modalityProcessingHasBeenSet = false;
+
+  AudioLanguageConfiguration m_languageConfiguration;
+  bool m_languageConfigurationHasBeenSet = false;
 };
 
 }  // namespace Model

generated/src/aws-cpp-sdk-bedrock-data-automation/include/aws/bedrock-data-automation/model/Language.h

@@ -0,0 +1,22 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/bedrock-data-automation/BedrockDataAutomation_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws {
+namespace BedrockDataAutomation {
+namespace Model {
+enum class Language { NOT_SET, EN, DE, ES, FR, IT, PT, JA, KO, CN, TW, HK };
+
+namespace LanguageMapper {
+AWS_BEDROCKDATAAUTOMATION_API Language GetLanguageForName(const Aws::String& name);
+
+AWS_BEDROCKDATAAUTOMATION_API Aws::String GetNameForLanguage(Language value);
+}  // namespace LanguageMapper
+}  // namespace Model
+}  // namespace BedrockDataAutomation
+}  // namespace Aws

generated/src/aws-cpp-sdk-bedrock-data-automation/source/model/AudioGenerativeOutputLanguage.cpp

@@ -0,0 +1,58 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/bedrock-data-automation/model/AudioGenerativeOutputLanguage.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+#include <aws/core/utils/HashingUtils.h>
+
+using namespace Aws::Utils;
+
+namespace Aws {
+namespace BedrockDataAutomation {
+namespace Model {
+namespace AudioGenerativeOutputLanguageMapper {
+
+static const int DEFAULT_HASH = HashingUtils::HashString("DEFAULT");
+static const int EN_HASH = HashingUtils::HashString("EN");
+
+AudioGenerativeOutputLanguage GetAudioGenerativeOutputLanguageForName(const Aws::String& name) {
+  int hashCode = HashingUtils::HashString(name.c_str());
+  if (hashCode == DEFAULT_HASH) {
+    return AudioGenerativeOutputLanguage::DEFAULT;
+  } else if (hashCode == EN_HASH) {
+    return AudioGenerativeOutputLanguage::EN;
+  }
+  EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+  if (overflowContainer) {
+    overflowContainer->StoreOverflow(hashCode, name);
+    return static_cast<AudioGenerativeOutputLanguage>(hashCode);
+  }
+
+  return AudioGenerativeOutputLanguage::NOT_SET;
+}
+
+Aws::String GetNameForAudioGenerativeOutputLanguage(AudioGenerativeOutputLanguage enumValue) {
+  switch (enumValue) {
+    case AudioGenerativeOutputLanguage::NOT_SET:
+      return {};
+    case AudioGenerativeOutputLanguage::DEFAULT:
+      return "DEFAULT";
+    case AudioGenerativeOutputLanguage::EN:
+      return "EN";
+    default:
+      EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+      if (overflowContainer) {
+        return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+      }
+
+      return {};
+  }
+}
+
+}  // namespace AudioGenerativeOutputLanguageMapper
+}  // namespace Model
+}  // namespace BedrockDataAutomation
+}  // namespace Aws

generated/src/aws-cpp-sdk-bedrock-data-automation/source/model/AudioLanguageConfiguration.cpp

@@ -0,0 +1,65 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/bedrock-data-automation/model/AudioLanguageConfiguration.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws {
+namespace BedrockDataAutomation {
+namespace Model {
+
+AudioLanguageConfiguration::AudioLanguageConfiguration(JsonView jsonValue) { *this = jsonValue; }
+
+AudioLanguageConfiguration& AudioLanguageConfiguration::operator=(JsonView jsonValue) {
+  if (jsonValue.ValueExists("inputLanguages")) {
+    Aws::Utils::Array<JsonView> inputLanguagesJsonList = jsonValue.GetArray("inputLanguages");
+    for (unsigned inputLanguagesIndex = 0; inputLanguagesIndex < inputLanguagesJsonList.GetLength(); ++inputLanguagesIndex) {
+      m_inputLanguages.push_back(LanguageMapper::GetLanguageForName(inputLanguagesJsonList[inputLanguagesIndex].AsString()));
+    }
+    m_inputLanguagesHasBeenSet = true;
+  }
+  if (jsonValue.ValueExists("generativeOutputLanguage")) {
+    m_generativeOutputLanguage =
+        AudioGenerativeOutputLanguageMapper::GetAudioGenerativeOutputLanguageForName(jsonValue.GetString("generativeOutputLanguage"));
+    m_generativeOutputLanguageHasBeenSet = true;
+  }
+  if (jsonValue.ValueExists("identifyMultipleLanguages")) {
+    m_identifyMultipleLanguages = jsonValue.GetBool("identifyMultipleLanguages");
+    m_identifyMultipleLanguagesHasBeenSet = true;
+  }
+  return *this;
+}
+
+JsonValue AudioLanguageConfiguration::Jsonize() const {
+  JsonValue payload;
+
+  if (m_inputLanguagesHasBeenSet) {
+    Aws::Utils::Array<JsonValue> inputLanguagesJsonList(m_inputLanguages.size());
+    for (unsigned inputLanguagesIndex = 0; inputLanguagesIndex < inputLanguagesJsonList.GetLength(); ++inputLanguagesIndex) {
+      inputLanguagesJsonList[inputLanguagesIndex].AsString(LanguageMapper::GetNameForLanguage(m_inputLanguages[inputLanguagesIndex]));
+    }
+    payload.WithArray("inputLanguages", std::move(inputLanguagesJsonList));
+  }
+
+  if (m_generativeOutputLanguageHasBeenSet) {
+    payload.WithString("generativeOutputLanguage",
+                       AudioGenerativeOutputLanguageMapper::GetNameForAudioGenerativeOutputLanguage(m_generativeOutputLanguage));
+  }
+
+  if (m_identifyMultipleLanguagesHasBeenSet) {
+    payload.WithBool("identifyMultipleLanguages", m_identifyMultipleLanguages);
+  }
+
+  return payload;
+}
+
+}  // namespace Model
+}  // namespace BedrockDataAutomation
+}  // namespace Aws