Merge branch 'main' into smoke-tests

Author: pulimsr

VERSION

@@ -1 +1 @@
-1.11.634
+1.11.636

generated/src/aws-cpp-sdk-amplifybackend/source/AmplifyBackendEndpointRules.cpp

@@ -504,13 +504,13 @@ namespace ARCZonalShift
         /**
          * <p>The zonal autoshift configuration for a resource includes the practice run
          * configuration and the status for running autoshifts, zonal autoshift status.
-         * When a resource has a practice run configuation, ARC starts weekly zonal shifts
+         * When a resource has a practice run configuration, ARC starts weekly zonal shifts
          * for the resource, to shift traffic away from an Availability Zone. Weekly
          * practice runs help you to make sure that your application can continue to
          * operate normally with the loss of one Availability Zone.</p> <p>You can update
-         * the zonal autoshift autoshift status to enable or disable zonal autoshift. When
-         * zonal autoshift is <code>ENABLED</code>, you authorize Amazon Web Services to
-         * shift away resource traffic for an application from an Availability Zone during
+         * the zonal autoshift status to enable or disable zonal autoshift. When zonal
+         * autoshift is <code>ENABLED</code>, you authorize Amazon Web Services to shift
+         * away resource traffic for an application from an Availability Zone during
          * events, on your behalf, to help reduce time to recovery. Traffic is also shifted
          * away for the required weekly practice runs.</p><p><h3>See Also:</h3>   <a
          * href="http://docs.aws.amazon.com/goto/WebAPI/arc-zonal-shift-2022-10-30/UpdateZonalAutoshiftConfiguration">AWS

generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/ARCZonalShiftClient.h

@@ -26,7 +26,8 @@ namespace Model
     PracticeOutcomeAlarmsRed,
     PracticeBlockingAlarmsRed,
     PracticeInBlockedDates,
-    PracticeInBlockedWindows
+    PracticeInBlockedWindows,
+    PracticeOutsideAllowedWindows
   };
 
 namespace ConflictExceptionReasonMapper

generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/model/ConflictExceptionReason.h

@@ -66,9 +66,11 @@ namespace Model
      * for practice runs are in UTC. Also, be aware of potential time adjustments that
      * might be required for daylight saving time differences. Separate multiple
      * blocked windows with spaces.</p> <p>For example, say you run business report
-     * summaries three days a week. For this scenario, you might set the following
-     * recurring days and times as blocked windows, for example: <code>MON-20:30-21:30
-     * WED-20:30-21:30 FRI-20:30-21:30</code>.</p>
+     * summaries three days a week. For this scenario, you could set the following
+     * recurring days and times as blocked windows, for example:
+     * <code>Mon:00:00-Mon:10:00 Wed-20:30-Wed:21:30 Fri-20:30-Fri:21:30</code>.</p>
+     *  <p>The <code>blockedWindows</code> have to start and end on the same
+     * day. Windows that span multiple days aren't supported.</p> 
      */
     inline const Aws::Vector<Aws::String>& GetBlockedWindows() const { return m_blockedWindows; }
     inline bool BlockedWindowsHasBeenSet() const { return m_blockedWindowsHasBeenSet; }
@@ -102,10 +104,9 @@ namespace Model
 
     ///@{
     /**
-     * <p>An Amazon CloudWatch alarm that you can specify for zonal autoshift practice
-     * runs. This alarm blocks ARC from starting practice run zonal shifts, and ends a
-     * practice run that's in progress, when the alarm is in an <code>ALARM</code>
-     * state. </p>
+     * <p> <i>Blocking alarms</i> for practice runs are optional alarms that you can
+     * specify that block practice runs when one or more of the alarms is in an
+     * <code>ALARM</code> state.</p>
      */
     inline const Aws::Vector<ControlCondition>& GetBlockingAlarms() const { return m_blockingAlarms; }
     inline bool BlockingAlarmsHasBeenSet() const { return m_blockingAlarmsHasBeenSet; }
@@ -119,14 +120,37 @@ namespace Model
 
     ///@{
     /**
-     * <p>The <i>outcome alarm</i> for practice runs is a required Amazon CloudWatch
-     * alarm that you specify that ends a practice run when the alarm is in an
-     * <code>ALARM</code> state.</p> <p>Configure the alarm to monitor the health of
+     * <p>Optionally, you can allow ARC to start practice runs for specific windows of
+     * days and times. </p> <p>The format for allowed windows is: DAY:HH:SS-DAY:HH:SS.
+     * Keep in mind, when you specify dates, that dates and times for practice runs are
+     * in UTC. Also, be aware of potential time adjustments that might be required for
+     * daylight saving time differences. Separate multiple allowed windows with
+     * spaces.</p> <p>For example, say you want to allow practice runs only on
+     * Wednesdays and Fridays from noon to 5 p.m. For this scenario, you could set the
+     * following recurring days and times as allowed windows, for example:
+     * <code>Wed-12:00-Wed:17:00 Fri-12:00-Fri:17:00</code>.</p>  <p>The
+     * <code>allowedWindows</code> have to start and end on the same day. Windows that
+     * span multiple days aren't supported.</p> 
+     */
+    inline const Aws::Vector<Aws::String>& GetAllowedWindows() const { return m_allowedWindows; }
+    inline bool AllowedWindowsHasBeenSet() const { return m_allowedWindowsHasBeenSet; }
+    template<typename AllowedWindowsT = Aws::Vector<Aws::String>>
+    void SetAllowedWindows(AllowedWindowsT&& value) { m_allowedWindowsHasBeenSet = true; m_allowedWindows = std::forward<AllowedWindowsT>(value); }
+    template<typename AllowedWindowsT = Aws::Vector<Aws::String>>
+    CreatePracticeRunConfigurationRequest& WithAllowedWindows(AllowedWindowsT&& value) { SetAllowedWindows(std::forward<AllowedWindowsT>(value)); return *this;}
+    template<typename AllowedWindowsT = Aws::String>
+    CreatePracticeRunConfigurationRequest& AddAllowedWindows(AllowedWindowsT&& value) { m_allowedWindowsHasBeenSet = true; m_allowedWindows.emplace_back(std::forward<AllowedWindowsT>(value)); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p> <i>Outcome alarms</i> for practice runs are alarms that you specify that end
+     * a practice run when one or more of the alarms is in an <code>ALARM</code>
+     * state.</p> <p>Configure one or more of these alarms to monitor the health of
      * your application when traffic is shifted away from an Availability Zone during
-     * each practice run. You should configure the alarm to go into an
-     * <code>ALARM</code> state if your application is impacted by the zonal shift, and
-     * you want to stop the zonal shift, to let traffic for the resource return to the
-     * Availability Zone.</p>
+     * each practice run. You should configure these alarms to go into an
+     * <code>ALARM</code> state if you want to stop a zonal shift, to let traffic for
+     * the resource return to the original Availability Zone.</p>
      */
     inline const Aws::Vector<ControlCondition>& GetOutcomeAlarms() const { return m_outcomeAlarms; }
     inline bool OutcomeAlarmsHasBeenSet() const { return m_outcomeAlarmsHasBeenSet; }
@@ -151,6 +175,9 @@ namespace Model
     Aws::Vector<ControlCondition> m_blockingAlarms;
     bool m_blockingAlarmsHasBeenSet = false;
 
+    Aws::Vector<Aws::String> m_allowedWindows;
+    bool m_allowedWindowsHasBeenSet = false;
+
     Aws::Vector<ControlCondition> m_outcomeAlarms;
     bool m_outcomeAlarmsHasBeenSet = false;
   };

generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/model/CreatePracticeRunConfigurationRequest.h

@@ -51,9 +51,9 @@ namespace Model
 
     ///@{
     /**
-     * <p>The <i>blocking alarm</i> for practice runs is an optional alarm that you can
-     * specify that blocks practice runs when the alarm is in an <code>ALARM</code>
-     * state.</p>
+     * <p> <i>Blocking alarms</i> for practice runs are optional alarms that you can
+     * specify that block practice runs when one or more of the alarms is in an
+     * <code>ALARM</code> state.</p>
      */
     inline const Aws::Vector<ControlCondition>& GetBlockingAlarms() const { return m_blockingAlarms; }
     inline bool BlockingAlarmsHasBeenSet() const { return m_blockingAlarmsHasBeenSet; }
@@ -67,8 +67,9 @@ namespace Model
 
     ///@{
     /**
-     * <p>The <i>outcome alarm</i> for practice runs is an alarm that you specify that
-     * ends a practice run when the alarm is in an <code>ALARM</code> state.</p>
+     * <p> <i>Outcome alarms</i> for practice runs are alarms that you specify that end
+     * a practice run when one or more of the alarms is in an <code>ALARM</code>
+     * state.</p>
      */
     inline const Aws::Vector<ControlCondition>& GetOutcomeAlarms() const { return m_outcomeAlarms; }
     inline bool OutcomeAlarmsHasBeenSet() const { return m_outcomeAlarmsHasBeenSet; }
@@ -85,7 +86,9 @@ namespace Model
      * <p>An array of one or more windows of days and times that you can block ARC from
      * starting practice runs for a resource.</p> <p>Specify the blocked windows in
      * UTC, using the format <code>DAY:HH:MM-DAY:HH:MM</code>, separated by spaces. For
-     * example, <code>MON:18:30-MON:19:30 TUE:18:30-TUE:19:30</code>.</p>
+     * example, <code>MON:18:30-MON:19:30 TUE:18:30-TUE:19:30</code>.</p> <p>The
+     * <code>blockedWindows</code> have to start and end on the same day. Windows that
+     * span multiple days aren't supported.</p>
      */
     inline const Aws::Vector<Aws::String>& GetBlockedWindows() const { return m_blockedWindows; }
     inline bool BlockedWindowsHasBeenSet() const { return m_blockedWindowsHasBeenSet; }
@@ -97,6 +100,26 @@ namespace Model
     PracticeRunConfiguration& AddBlockedWindows(BlockedWindowsT&& value) { m_blockedWindowsHasBeenSet = true; m_blockedWindows.emplace_back(std::forward<BlockedWindowsT>(value)); return *this; }
     ///@}
 
+    ///@{
+    /**
+     * <p>An array of one or more windows of days and times that you can allow ARC to
+     * start practice runs for a resource.</p> <p>For example, say you want to allow
+     * practice runs only on Wednesdays and Fridays from noon to 5 p.m. For this
+     * scenario, you could set the following recurring days and times as allowed
+     * windows, for example: <code>Wed-12:00-Wed:17:00 Fri-12:00-Fri:17:00</code>.</p>
+     * <p>The <code>allowedWindows</code> have to start and end on the same day.
+     * Windows that span multiple days aren't supported.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetAllowedWindows() const { return m_allowedWindows; }
+    inline bool AllowedWindowsHasBeenSet() const { return m_allowedWindowsHasBeenSet; }
+    template<typename AllowedWindowsT = Aws::Vector<Aws::String>>
+    void SetAllowedWindows(AllowedWindowsT&& value) { m_allowedWindowsHasBeenSet = true; m_allowedWindows = std::forward<AllowedWindowsT>(value); }
+    template<typename AllowedWindowsT = Aws::Vector<Aws::String>>
+    PracticeRunConfiguration& WithAllowedWindows(AllowedWindowsT&& value) { SetAllowedWindows(std::forward<AllowedWindowsT>(value)); return *this;}
+    template<typename AllowedWindowsT = Aws::String>
+    PracticeRunConfiguration& AddAllowedWindows(AllowedWindowsT&& value) { m_allowedWindowsHasBeenSet = true; m_allowedWindows.emplace_back(std::forward<AllowedWindowsT>(value)); return *this; }
+    ///@}
+
     ///@{
     /**
      * <p>An array of one or more dates that you can specify when Amazon Web Services
@@ -123,6 +146,9 @@ namespace Model
     Aws::Vector<Aws::String> m_blockedWindows;
     bool m_blockedWindowsHasBeenSet = false;
 
+    Aws::Vector<Aws::String> m_allowedWindows;
+    bool m_allowedWindowsHasBeenSet = false;
+
     Aws::Vector<Aws::String> m_blockedDates;
     bool m_blockedDatesHasBeenSet = false;
   };

generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/model/PracticeRunConfiguration.h

@@ -93,8 +93,8 @@ namespace Model
 
     ///@{
     /**
-     * <p>Add, change, or remove the Amazon CloudWatch alarm that you optionally
-     * specify as the blocking alarm for practice runs.</p>
+     * <p>Add, change, or remove the Amazon CloudWatch alarms that you optionally
+     * specify as the blocking alarms for practice runs.</p>
      */
     inline const Aws::Vector<ControlCondition>& GetBlockingAlarms() const { return m_blockingAlarms; }
     inline bool BlockingAlarmsHasBeenSet() const { return m_blockingAlarmsHasBeenSet; }
@@ -108,8 +108,33 @@ namespace Model
 
     ///@{
     /**
-     * <p>Specify a new the Amazon CloudWatch alarm as the outcome alarm for practice
-     * runs.</p>
+     * <p>Add, change, or remove windows of days and times for when you can,
+     * optionally, allow ARC to start a practice run for a resource.</p> <p>The format
+     * for allowed windows is: DAY:HH:SS-DAY:HH:SS. Keep in mind, when you specify
+     * dates, that dates and times for practice runs are in UTC. Also, be aware of
+     * potential time adjustments that might be required for daylight saving time
+     * differences. Separate multiple allowed windows with spaces.</p> <p>For example,
+     * say you want to allow practice runs only on Wednesdays and Fridays from noon to
+     * 5 p.m. For this scenario, you could set the following recurring days and times
+     * as allowed windows, for example: <code>Wed-12:00-Wed:17:00
+     * Fri-12:00-Fri:17:00</code>.</p>  <p>The <code>allowedWindows</code>
+     * have to start and end on the same day. Windows that span multiple days aren't
+     * supported.</p> 
+     */
+    inline const Aws::Vector<Aws::String>& GetAllowedWindows() const { return m_allowedWindows; }
+    inline bool AllowedWindowsHasBeenSet() const { return m_allowedWindowsHasBeenSet; }
+    template<typename AllowedWindowsT = Aws::Vector<Aws::String>>
+    void SetAllowedWindows(AllowedWindowsT&& value) { m_allowedWindowsHasBeenSet = true; m_allowedWindows = std::forward<AllowedWindowsT>(value); }
+    template<typename AllowedWindowsT = Aws::Vector<Aws::String>>
+    UpdatePracticeRunConfigurationRequest& WithAllowedWindows(AllowedWindowsT&& value) { SetAllowedWindows(std::forward<AllowedWindowsT>(value)); return *this;}
+    template<typename AllowedWindowsT = Aws::String>
+    UpdatePracticeRunConfigurationRequest& AddAllowedWindows(AllowedWindowsT&& value) { m_allowedWindowsHasBeenSet = true; m_allowedWindows.emplace_back(std::forward<AllowedWindowsT>(value)); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specify one or more Amazon CloudWatch alarms as the outcome alarms for
+     * practice runs.</p>
      */
     inline const Aws::Vector<ControlCondition>& GetOutcomeAlarms() const { return m_outcomeAlarms; }
     inline bool OutcomeAlarmsHasBeenSet() const { return m_outcomeAlarmsHasBeenSet; }
@@ -134,6 +159,9 @@ namespace Model
     Aws::Vector<ControlCondition> m_blockingAlarms;
     bool m_blockingAlarmsHasBeenSet = false;
 
+    Aws::Vector<Aws::String> m_allowedWindows;
+    bool m_allowedWindowsHasBeenSet = false;
+
     Aws::Vector<ControlCondition> m_outcomeAlarms;
     bool m_outcomeAlarmsHasBeenSet = false;
   };

generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/model/UpdatePracticeRunConfigurationRequest.h

@@ -28,7 +28,9 @@ namespace Model
     InvalidPracticeBlocker,
     FISExperimentUpdateNotAllowed,
     AutoshiftUpdateNotAllowed,
-    UnsupportedPracticeCancelShiftType
+    UnsupportedPracticeCancelShiftType,
+    InvalidPracticeAllowedWindow,
+    InvalidPracticeWindows
   };
 
 namespace ValidationExceptionReasonMapper

generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/model/ValidationExceptionReason.h

@@ -31,6 +31,7 @@ namespace Aws
         static const int PracticeBlockingAlarmsRed_HASH = HashingUtils::HashString("PracticeBlockingAlarmsRed");
         static const int PracticeInBlockedDates_HASH = HashingUtils::HashString("PracticeInBlockedDates");
         static const int PracticeInBlockedWindows_HASH = HashingUtils::HashString("PracticeInBlockedWindows");
+        static const int PracticeOutsideAllowedWindows_HASH = HashingUtils::HashString("PracticeOutsideAllowedWindows");
 
 
         ConflictExceptionReason GetConflictExceptionReasonForName(const Aws::String& name)
@@ -80,6 +81,10 @@ namespace Aws
           {
             return ConflictExceptionReason::PracticeInBlockedWindows;
           }
+          else if (hashCode == PracticeOutsideAllowedWindows_HASH)
+          {
+            return ConflictExceptionReason::PracticeOutsideAllowedWindows;
+          }
           EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
           if(overflowContainer)
           {
@@ -118,6 +123,8 @@ namespace Aws
             return "PracticeInBlockedDates";
           case ConflictExceptionReason::PracticeInBlockedWindows:
             return "PracticeInBlockedWindows";
+          case ConflictExceptionReason::PracticeOutsideAllowedWindows:
+            return "PracticeOutsideAllowedWindows";
           default:
             EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
             if(overflowContainer)

generated/src/aws-cpp-sdk-arc-zonal-shift/source/model/ConflictExceptionReason.cpp

@@ -55,6 +55,17 @@ Aws::String CreatePracticeRunConfigurationRequest::SerializePayload() const
 
   }
 
+  if(m_allowedWindowsHasBeenSet)
+  {
+   Aws::Utils::Array<JsonValue> allowedWindowsJsonList(m_allowedWindows.size());
+   for(unsigned allowedWindowsIndex = 0; allowedWindowsIndex < allowedWindowsJsonList.GetLength(); ++allowedWindowsIndex)
+   {
+     allowedWindowsJsonList[allowedWindowsIndex].AsString(m_allowedWindows[allowedWindowsIndex]);
+   }
+   payload.WithArray("allowedWindows", std::move(allowedWindowsJsonList));
+
+  }
+
   if(m_outcomeAlarmsHasBeenSet)
   {
    Aws::Utils::Array<JsonValue> outcomeAlarmsJsonList(m_outcomeAlarms.size());