diff --git a/clients/client-acm-pca/waiters/waitForAuditReportCreated.ts b/clients/client-acm-pca/waiters/waitForAuditReportCreated.ts
index b1e1d58a5f0ad..785cd1839387a 100644
--- a/clients/client-acm-pca/waiters/waitForAuditReportCreated.ts
+++ b/clients/client-acm-pca/waiters/waitForAuditReportCreated.ts
@@ -3,20 +3,22 @@ import {
   DescribeCertificateAuthorityAuditReportCommand,
   DescribeCertificateAuthorityAuditReportCommandInput,
 } from "../commands/DescribeCertificateAuthorityAuditReportCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: ACMPCAClient,
   input: DescribeCertificateAuthorityAuditReportCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeCertificateAuthorityAuditReportCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.AuditReportStatus;
       };
       if (returnComparator() === "SUCCESS") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -24,16 +26,17 @@ const checkState = async (
         return result.AuditReportStatus;
       };
       if (returnComparator() === "FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a Audit Report is created
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeCertificateAuthorityAuditReportCommand for polling.
+ *  @deprecated Use waitUntilAuditReportCreated instead. waitForAuditReportCreated does not throw error in non-success cases.
  */
 export const waitForAuditReportCreated = async (
   params: WaiterConfiguration<ACMPCAClient>,
@@ -42,3 +45,16 @@ export const waitForAuditReportCreated = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a Audit Report is created
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeCertificateAuthorityAuditReportCommand for polling.
+ */
+export const waitUntilAuditReportCreated = async (
+  params: WaiterConfiguration<ACMPCAClient>,
+  input: DescribeCertificateAuthorityAuditReportCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-acm-pca/waiters/waitForCertificateAuthorityCSRCreated.ts b/clients/client-acm-pca/waiters/waitForCertificateAuthorityCSRCreated.ts
index fb4cde04354ff..b0290638c562b 100644
--- a/clients/client-acm-pca/waiters/waitForCertificateAuthorityCSRCreated.ts
+++ b/clients/client-acm-pca/waiters/waitForCertificateAuthorityCSRCreated.ts
@@ -3,26 +3,28 @@ import {
   GetCertificateAuthorityCsrCommand,
   GetCertificateAuthorityCsrCommandInput,
 } from "../commands/GetCertificateAuthorityCsrCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: ACMPCAClient,
   input: GetCertificateAuthorityCsrCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetCertificateAuthorityCsrCommand(input));
-    return { state: WaiterState.SUCCESS };
+    reason = result;
+    return { state: WaiterState.SUCCESS, reason };
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "RequestInProgressException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a Certificate Authority CSR is created
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetCertificateAuthorityCsrCommand for polling.
+ *  @deprecated Use waitUntilCertificateAuthorityCSRCreated instead. waitForCertificateAuthorityCSRCreated does not throw error in non-success cases.
  */
 export const waitForCertificateAuthorityCSRCreated = async (
   params: WaiterConfiguration<ACMPCAClient>,
@@ -31,3 +33,16 @@ export const waitForCertificateAuthorityCSRCreated = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a Certificate Authority CSR is created
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetCertificateAuthorityCsrCommand for polling.
+ */
+export const waitUntilCertificateAuthorityCSRCreated = async (
+  params: WaiterConfiguration<ACMPCAClient>,
+  input: GetCertificateAuthorityCsrCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-acm-pca/waiters/waitForCertificateIssued.ts b/clients/client-acm-pca/waiters/waitForCertificateIssued.ts
index 99e1f411a5c83..635c15b5b33e8 100644
--- a/clients/client-acm-pca/waiters/waitForCertificateIssued.ts
+++ b/clients/client-acm-pca/waiters/waitForCertificateIssued.ts
@@ -1,22 +1,24 @@
 import { ACMPCAClient } from "../ACMPCAClient";
 import { GetCertificateCommand, GetCertificateCommandInput } from "../commands/GetCertificateCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: ACMPCAClient, input: GetCertificateCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetCertificateCommand(input));
-    return { state: WaiterState.SUCCESS };
+    reason = result;
+    return { state: WaiterState.SUCCESS, reason };
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "RequestInProgressException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a certificate is issued
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetCertificateCommand for polling.
+ *  @deprecated Use waitUntilCertificateIssued instead. waitForCertificateIssued does not throw error in non-success cases.
  */
 export const waitForCertificateIssued = async (
   params: WaiterConfiguration<ACMPCAClient>,
@@ -25,3 +27,16 @@ export const waitForCertificateIssued = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a certificate is issued
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetCertificateCommand for polling.
+ */
+export const waitUntilCertificateIssued = async (
+  params: WaiterConfiguration<ACMPCAClient>,
+  input: GetCertificateCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-acm/waiters/waitForCertificateValidated.ts b/clients/client-acm/waiters/waitForCertificateValidated.ts
index 64bbc1edc758c..9ea971c573dc1 100644
--- a/clients/client-acm/waiters/waitForCertificateValidated.ts
+++ b/clients/client-acm/waiters/waitForCertificateValidated.ts
@@ -1,10 +1,12 @@
 import { ACMClient } from "../ACMClient";
 import { DescribeCertificateCommand, DescribeCertificateCommandInput } from "../commands/DescribeCertificateCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: ACMClient, input: DescribeCertificateCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeCertificateCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Certificate.DomainValidationOptions);
@@ -18,7 +20,7 @@ const checkState = async (client: ACMClient, input: DescribeCertificateCommandIn
         allStringEq_5 = allStringEq_5 && element_4 == "SUCCESS";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: ACMClient, input: DescribeCertificateCommandIn
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "PENDING_VALIDATION") {
-          return { state: WaiterState.RETRY };
+          return { state: WaiterState.RETRY, reason };
         }
       }
     } catch (e) {}
@@ -40,20 +42,20 @@ const checkState = async (client: ACMClient, input: DescribeCertificateCommandIn
         return result.Certificate.Status;
       };
       if (returnComparator() === "FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.FAILURE };
+      return { state: WaiterState.FAILURE, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeCertificateCommand for polling.
+ *  @deprecated Use waitUntilCertificateValidated instead. waitForCertificateValidated does not throw error in non-success cases.
  */
 export const waitForCertificateValidated = async (
   params: WaiterConfiguration<ACMClient>,
@@ -62,3 +64,16 @@ export const waitForCertificateValidated = async (
   const serviceDefaults = { minDelay: 60, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeCertificateCommand for polling.
+ */
+export const waitUntilCertificateValidated = async (
+  params: WaiterConfiguration<ACMClient>,
+  input: DescribeCertificateCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-appstream/waiters/waitForFleetStarted.ts b/clients/client-appstream/waiters/waitForFleetStarted.ts
index f35f5c5fa5d4f..d53cd31a1e760 100644
--- a/clients/client-appstream/waiters/waitForFleetStarted.ts
+++ b/clients/client-appstream/waiters/waitForFleetStarted.ts
@@ -1,10 +1,12 @@
 import { AppStreamClient } from "../AppStreamClient";
 import { DescribeFleetsCommand, DescribeFleetsCommandInput } from "../commands/DescribeFleetsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeFleetsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Fleets);
@@ -18,7 +20,7 @@ const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandI
         allStringEq_5 = allStringEq_5 && element_4 == "ACTIVE";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandI
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "PENDING_DEACTIVATE") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -45,17 +47,18 @@ const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandI
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "INACTIVE") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeFleetsCommand for polling.
+ *  @deprecated Use waitUntilFleetStarted instead. waitForFleetStarted does not throw error in non-success cases.
  */
 export const waitForFleetStarted = async (
   params: WaiterConfiguration<AppStreamClient>,
@@ -64,3 +67,16 @@ export const waitForFleetStarted = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeFleetsCommand for polling.
+ */
+export const waitUntilFleetStarted = async (
+  params: WaiterConfiguration<AppStreamClient>,
+  input: DescribeFleetsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-appstream/waiters/waitForFleetStopped.ts b/clients/client-appstream/waiters/waitForFleetStopped.ts
index 0ec182e362d9d..6178d0b9a3104 100644
--- a/clients/client-appstream/waiters/waitForFleetStopped.ts
+++ b/clients/client-appstream/waiters/waitForFleetStopped.ts
@@ -1,10 +1,12 @@
 import { AppStreamClient } from "../AppStreamClient";
 import { DescribeFleetsCommand, DescribeFleetsCommandInput } from "../commands/DescribeFleetsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeFleetsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Fleets);
@@ -18,7 +20,7 @@ const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandI
         allStringEq_5 = allStringEq_5 && element_4 == "INACTIVE";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandI
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "PENDING_ACTIVATE") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -45,17 +47,18 @@ const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandI
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "ACTIVE") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeFleetsCommand for polling.
+ *  @deprecated Use waitUntilFleetStopped instead. waitForFleetStopped does not throw error in non-success cases.
  */
 export const waitForFleetStopped = async (
   params: WaiterConfiguration<AppStreamClient>,
@@ -64,3 +67,16 @@ export const waitForFleetStopped = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeFleetsCommand for polling.
+ */
+export const waitUntilFleetStopped = async (
+  params: WaiterConfiguration<AppStreamClient>,
+  input: DescribeFleetsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-auto-scaling/waiters/waitForGroupExists.ts b/clients/client-auto-scaling/waiters/waitForGroupExists.ts
index aadb63ee2e2bd..d28ed406ffaf2 100644
--- a/clients/client-auto-scaling/waiters/waitForGroupExists.ts
+++ b/clients/client-auto-scaling/waiters/waitForGroupExists.ts
@@ -3,20 +3,22 @@ import {
   DescribeAutoScalingGroupsCommand,
   DescribeAutoScalingGroupsCommandInput,
 } from "../commands/DescribeAutoScalingGroupsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: AutoScalingClient,
   input: DescribeAutoScalingGroupsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeAutoScalingGroupsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.AutoScalingGroups.length > 0.0;
       };
       if (returnComparator() == true) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -24,16 +26,17 @@ const checkState = async (
         return result.AutoScalingGroups.length > 0.0;
       };
       if (returnComparator() == false) {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeAutoScalingGroupsCommand for polling.
+ *  @deprecated Use waitUntilGroupExists instead. waitForGroupExists does not throw error in non-success cases.
  */
 export const waitForGroupExists = async (
   params: WaiterConfiguration<AutoScalingClient>,
@@ -42,3 +45,16 @@ export const waitForGroupExists = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeAutoScalingGroupsCommand for polling.
+ */
+export const waitUntilGroupExists = async (
+  params: WaiterConfiguration<AutoScalingClient>,
+  input: DescribeAutoScalingGroupsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-auto-scaling/waiters/waitForGroupInService.ts b/clients/client-auto-scaling/waiters/waitForGroupInService.ts
index 2f884afa07b6d..6f0ecf9698c9b 100644
--- a/clients/client-auto-scaling/waiters/waitForGroupInService.ts
+++ b/clients/client-auto-scaling/waiters/waitForGroupInService.ts
@@ -3,14 +3,16 @@ import {
   DescribeAutoScalingGroupsCommand,
   DescribeAutoScalingGroupsCommandInput,
 } from "../commands/DescribeAutoScalingGroupsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: AutoScalingClient,
   input: DescribeAutoScalingGroupsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeAutoScalingGroupsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.AutoScalingGroups);
@@ -27,7 +29,7 @@ const checkState = async (
         return flat_7.includes(false);
       };
       if (returnComparator() == false) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -46,16 +48,17 @@ const checkState = async (
         return flat_7.includes(false);
       };
       if (returnComparator() == true) {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeAutoScalingGroupsCommand for polling.
+ *  @deprecated Use waitUntilGroupInService instead. waitForGroupInService does not throw error in non-success cases.
  */
 export const waitForGroupInService = async (
   params: WaiterConfiguration<AutoScalingClient>,
@@ -64,3 +67,16 @@ export const waitForGroupInService = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeAutoScalingGroupsCommand for polling.
+ */
+export const waitUntilGroupInService = async (
+  params: WaiterConfiguration<AutoScalingClient>,
+  input: DescribeAutoScalingGroupsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-auto-scaling/waiters/waitForGroupNotExists.ts b/clients/client-auto-scaling/waiters/waitForGroupNotExists.ts
index ba83587743345..c45d4f6c4f67c 100644
--- a/clients/client-auto-scaling/waiters/waitForGroupNotExists.ts
+++ b/clients/client-auto-scaling/waiters/waitForGroupNotExists.ts
@@ -3,20 +3,22 @@ import {
   DescribeAutoScalingGroupsCommand,
   DescribeAutoScalingGroupsCommandInput,
 } from "../commands/DescribeAutoScalingGroupsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: AutoScalingClient,
   input: DescribeAutoScalingGroupsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeAutoScalingGroupsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.AutoScalingGroups.length > 0.0;
       };
       if (returnComparator() == false) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -24,16 +26,17 @@ const checkState = async (
         return result.AutoScalingGroups.length > 0.0;
       };
       if (returnComparator() == true) {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeAutoScalingGroupsCommand for polling.
+ *  @deprecated Use waitUntilGroupNotExists instead. waitForGroupNotExists does not throw error in non-success cases.
  */
 export const waitForGroupNotExists = async (
   params: WaiterConfiguration<AutoScalingClient>,
@@ -42,3 +45,16 @@ export const waitForGroupNotExists = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeAutoScalingGroupsCommand for polling.
+ */
+export const waitUntilGroupNotExists = async (
+  params: WaiterConfiguration<AutoScalingClient>,
+  input: DescribeAutoScalingGroupsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-cloudformation/waiters/waitForTypeRegistrationComplete.ts b/clients/client-cloudformation/waiters/waitForTypeRegistrationComplete.ts
index 4e017cfa435c9..94aa8cdaef9fd 100644
--- a/clients/client-cloudformation/waiters/waitForTypeRegistrationComplete.ts
+++ b/clients/client-cloudformation/waiters/waitForTypeRegistrationComplete.ts
@@ -3,20 +3,22 @@ import {
   DescribeTypeRegistrationCommand,
   DescribeTypeRegistrationCommandInput,
 } from "../commands/DescribeTypeRegistrationCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: CloudFormationClient,
   input: DescribeTypeRegistrationCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeTypeRegistrationCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.ProgressStatus;
       };
       if (returnComparator() === "COMPLETE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -24,16 +26,17 @@ const checkState = async (
         return result.ProgressStatus;
       };
       if (returnComparator() === "FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until type registration is COMPLETE.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeTypeRegistrationCommand for polling.
+ *  @deprecated Use waitUntilTypeRegistrationComplete instead. waitForTypeRegistrationComplete does not throw error in non-success cases.
  */
 export const waitForTypeRegistrationComplete = async (
   params: WaiterConfiguration<CloudFormationClient>,
@@ -42,3 +45,16 @@ export const waitForTypeRegistrationComplete = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until type registration is COMPLETE.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeTypeRegistrationCommand for polling.
+ */
+export const waitUntilTypeRegistrationComplete = async (
+  params: WaiterConfiguration<CloudFormationClient>,
+  input: DescribeTypeRegistrationCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-cloudfront/waiters/waitForDistributionDeployed.ts b/clients/client-cloudfront/waiters/waitForDistributionDeployed.ts
index 842847ace97ef..01b852138a9d8 100644
--- a/clients/client-cloudfront/waiters/waitForDistributionDeployed.ts
+++ b/clients/client-cloudfront/waiters/waitForDistributionDeployed.ts
@@ -1,25 +1,28 @@
 import { CloudFrontClient } from "../CloudFrontClient";
 import { GetDistributionCommand, GetDistributionCommandInput } from "../commands/GetDistributionCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: CloudFrontClient, input: GetDistributionCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetDistributionCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.Distribution.Status;
       };
       if (returnComparator() === "Deployed") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a distribution is deployed.
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetDistributionCommand for polling.
+ *  @deprecated Use waitUntilDistributionDeployed instead. waitForDistributionDeployed does not throw error in non-success cases.
  */
 export const waitForDistributionDeployed = async (
   params: WaiterConfiguration<CloudFrontClient>,
@@ -28,3 +31,16 @@ export const waitForDistributionDeployed = async (
   const serviceDefaults = { minDelay: 60, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a distribution is deployed.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetDistributionCommand for polling.
+ */
+export const waitUntilDistributionDeployed = async (
+  params: WaiterConfiguration<CloudFrontClient>,
+  input: GetDistributionCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-cloudfront/waiters/waitForInvalidationCompleted.ts b/clients/client-cloudfront/waiters/waitForInvalidationCompleted.ts
index f4ca97b99ddf7..3b39348b8249d 100644
--- a/clients/client-cloudfront/waiters/waitForInvalidationCompleted.ts
+++ b/clients/client-cloudfront/waiters/waitForInvalidationCompleted.ts
@@ -1,25 +1,28 @@
 import { CloudFrontClient } from "../CloudFrontClient";
 import { GetInvalidationCommand, GetInvalidationCommandInput } from "../commands/GetInvalidationCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: CloudFrontClient, input: GetInvalidationCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetInvalidationCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.Invalidation.Status;
       };
       if (returnComparator() === "Completed") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until an invalidation has completed.
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetInvalidationCommand for polling.
+ *  @deprecated Use waitUntilInvalidationCompleted instead. waitForInvalidationCompleted does not throw error in non-success cases.
  */
 export const waitForInvalidationCompleted = async (
   params: WaiterConfiguration<CloudFrontClient>,
@@ -28,3 +31,16 @@ export const waitForInvalidationCompleted = async (
   const serviceDefaults = { minDelay: 20, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until an invalidation has completed.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetInvalidationCommand for polling.
+ */
+export const waitUntilInvalidationCompleted = async (
+  params: WaiterConfiguration<CloudFrontClient>,
+  input: GetInvalidationCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-cloudfront/waiters/waitForStreamingDistributionDeployed.ts b/clients/client-cloudfront/waiters/waitForStreamingDistributionDeployed.ts
index 080989b0e07e7..5fbde54b0cfbf 100644
--- a/clients/client-cloudfront/waiters/waitForStreamingDistributionDeployed.ts
+++ b/clients/client-cloudfront/waiters/waitForStreamingDistributionDeployed.ts
@@ -3,29 +3,32 @@ import {
   GetStreamingDistributionCommand,
   GetStreamingDistributionCommandInput,
 } from "../commands/GetStreamingDistributionCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: CloudFrontClient,
   input: GetStreamingDistributionCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetStreamingDistributionCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.StreamingDistribution.Status;
       };
       if (returnComparator() === "Deployed") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a streaming distribution is deployed.
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetStreamingDistributionCommand for polling.
+ *  @deprecated Use waitUntilStreamingDistributionDeployed instead. waitForStreamingDistributionDeployed does not throw error in non-success cases.
  */
 export const waitForStreamingDistributionDeployed = async (
   params: WaiterConfiguration<CloudFrontClient>,
@@ -34,3 +37,16 @@ export const waitForStreamingDistributionDeployed = async (
   const serviceDefaults = { minDelay: 60, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a streaming distribution is deployed.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetStreamingDistributionCommand for polling.
+ */
+export const waitUntilStreamingDistributionDeployed = async (
+  params: WaiterConfiguration<CloudFrontClient>,
+  input: GetStreamingDistributionCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-cloudwatch/waiters/waitForAlarmExists.ts b/clients/client-cloudwatch/waiters/waitForAlarmExists.ts
index b476a478bdecc..18c33e6dc5465 100644
--- a/clients/client-cloudwatch/waiters/waitForAlarmExists.ts
+++ b/clients/client-cloudwatch/waiters/waitForAlarmExists.ts
@@ -1,26 +1,29 @@
 import { CloudWatchClient } from "../CloudWatchClient";
 import { DescribeAlarmsCommand, DescribeAlarmsCommandInput } from "../commands/DescribeAlarmsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: CloudWatchClient, input: DescribeAlarmsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeAlarmsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.MetricAlarms);
         return flat_1.length > 0.0;
       };
       if (returnComparator() == true) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeAlarmsCommand for polling.
+ *  @deprecated Use waitUntilAlarmExists instead. waitForAlarmExists does not throw error in non-success cases.
  */
 export const waitForAlarmExists = async (
   params: WaiterConfiguration<CloudWatchClient>,
@@ -29,3 +32,16 @@ export const waitForAlarmExists = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeAlarmsCommand for polling.
+ */
+export const waitUntilAlarmExists = async (
+  params: WaiterConfiguration<CloudWatchClient>,
+  input: DescribeAlarmsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-cloudwatch/waiters/waitForCompositeAlarmExists.ts b/clients/client-cloudwatch/waiters/waitForCompositeAlarmExists.ts
index b6b51b47d62d5..965acb18794d8 100644
--- a/clients/client-cloudwatch/waiters/waitForCompositeAlarmExists.ts
+++ b/clients/client-cloudwatch/waiters/waitForCompositeAlarmExists.ts
@@ -1,26 +1,29 @@
 import { CloudWatchClient } from "../CloudWatchClient";
 import { DescribeAlarmsCommand, DescribeAlarmsCommandInput } from "../commands/DescribeAlarmsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: CloudWatchClient, input: DescribeAlarmsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeAlarmsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.CompositeAlarms);
         return flat_1.length > 0.0;
       };
       if (returnComparator() == true) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeAlarmsCommand for polling.
+ *  @deprecated Use waitUntilCompositeAlarmExists instead. waitForCompositeAlarmExists does not throw error in non-success cases.
  */
 export const waitForCompositeAlarmExists = async (
   params: WaiterConfiguration<CloudWatchClient>,
@@ -29,3 +32,16 @@ export const waitForCompositeAlarmExists = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeAlarmsCommand for polling.
+ */
+export const waitUntilCompositeAlarmExists = async (
+  params: WaiterConfiguration<CloudWatchClient>,
+  input: DescribeAlarmsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-codedeploy/waiters/waitForDeploymentSuccessful.ts b/clients/client-codedeploy/waiters/waitForDeploymentSuccessful.ts
index 30dfb4fada9ea..115497e443fea 100644
--- a/clients/client-codedeploy/waiters/waitForDeploymentSuccessful.ts
+++ b/clients/client-codedeploy/waiters/waitForDeploymentSuccessful.ts
@@ -1,16 +1,18 @@
 import { CodeDeployClient } from "../CodeDeployClient";
 import { GetDeploymentCommand, GetDeploymentCommandInput } from "../commands/GetDeploymentCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: CodeDeployClient, input: GetDeploymentCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetDeploymentCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.deploymentInfo.status;
       };
       if (returnComparator() === "Succeeded") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,7 +20,7 @@ const checkState = async (client: CodeDeployClient, input: GetDeploymentCommandI
         return result.deploymentInfo.status;
       };
       if (returnComparator() === "Failed") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -26,16 +28,17 @@ const checkState = async (client: CodeDeployClient, input: GetDeploymentCommandI
         return result.deploymentInfo.status;
       };
       if (returnComparator() === "Stopped") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetDeploymentCommand for polling.
+ *  @deprecated Use waitUntilDeploymentSuccessful instead. waitForDeploymentSuccessful does not throw error in non-success cases.
  */
 export const waitForDeploymentSuccessful = async (
   params: WaiterConfiguration<CodeDeployClient>,
@@ -44,3 +47,16 @@ export const waitForDeploymentSuccessful = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetDeploymentCommand for polling.
+ */
+export const waitUntilDeploymentSuccessful = async (
+  params: WaiterConfiguration<CodeDeployClient>,
+  input: GetDeploymentCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-database-migration-service/waiters/waitForEndpointDeleted.ts b/clients/client-database-migration-service/waiters/waitForEndpointDeleted.ts
index 9cec6ee4c2cf3..720c6f573fa56 100644
--- a/clients/client-database-migration-service/waiters/waitForEndpointDeleted.ts
+++ b/clients/client-database-migration-service/waiters/waitForEndpointDeleted.ts
@@ -1,13 +1,15 @@
 import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
 import { DescribeEndpointsCommand, DescribeEndpointsCommandInput } from "../commands/DescribeEndpointsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: DatabaseMigrationServiceClient,
   input: DescribeEndpointsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeEndpointsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Endpoints);
@@ -18,7 +20,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "active") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -32,21 +34,21 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "creating") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundFault") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until testing endpoint is deleted.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeEndpointsCommand for polling.
+ *  @deprecated Use waitUntilEndpointDeleted instead. waitForEndpointDeleted does not throw error in non-success cases.
  */
 export const waitForEndpointDeleted = async (
   params: WaiterConfiguration<DatabaseMigrationServiceClient>,
@@ -55,3 +57,16 @@ export const waitForEndpointDeleted = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until testing endpoint is deleted.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeEndpointsCommand for polling.
+ */
+export const waitUntilEndpointDeleted = async (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeEndpointsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-database-migration-service/waiters/waitForReplicationInstanceAvailable.ts b/clients/client-database-migration-service/waiters/waitForReplicationInstanceAvailable.ts
index 12aa540ed8da5..cc92641a1789a 100644
--- a/clients/client-database-migration-service/waiters/waitForReplicationInstanceAvailable.ts
+++ b/clients/client-database-migration-service/waiters/waitForReplicationInstanceAvailable.ts
@@ -3,14 +3,16 @@ import {
   DescribeReplicationInstancesCommand,
   DescribeReplicationInstancesCommandInput,
 } from "../commands/DescribeReplicationInstancesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: DatabaseMigrationServiceClient,
   input: DescribeReplicationInstancesCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeReplicationInstancesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ReplicationInstances);
@@ -24,7 +26,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,7 +39,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -51,7 +53,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "incompatible-credentials") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -65,7 +67,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "incompatible-network") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -79,17 +81,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "inaccessible-encryption-credentials") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until DMS replication instance is available.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeReplicationInstancesCommand for polling.
+ *  @deprecated Use waitUntilReplicationInstanceAvailable instead. waitForReplicationInstanceAvailable does not throw error in non-success cases.
  */
 export const waitForReplicationInstanceAvailable = async (
   params: WaiterConfiguration<DatabaseMigrationServiceClient>,
@@ -98,3 +101,16 @@ export const waitForReplicationInstanceAvailable = async (
   const serviceDefaults = { minDelay: 60, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until DMS replication instance is available.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeReplicationInstancesCommand for polling.
+ */
+export const waitUntilReplicationInstanceAvailable = async (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeReplicationInstancesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-database-migration-service/waiters/waitForReplicationInstanceDeleted.ts b/clients/client-database-migration-service/waiters/waitForReplicationInstanceDeleted.ts
index 966de9f0ea482..575b38c980eda 100644
--- a/clients/client-database-migration-service/waiters/waitForReplicationInstanceDeleted.ts
+++ b/clients/client-database-migration-service/waiters/waitForReplicationInstanceDeleted.ts
@@ -3,14 +3,16 @@ import {
   DescribeReplicationInstancesCommand,
   DescribeReplicationInstancesCommandInput,
 } from "../commands/DescribeReplicationInstancesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: DatabaseMigrationServiceClient,
   input: DescribeReplicationInstancesCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeReplicationInstancesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ReplicationInstances);
@@ -21,21 +23,21 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "available") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundFault") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until DMS replication instance is deleted.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeReplicationInstancesCommand for polling.
+ *  @deprecated Use waitUntilReplicationInstanceDeleted instead. waitForReplicationInstanceDeleted does not throw error in non-success cases.
  */
 export const waitForReplicationInstanceDeleted = async (
   params: WaiterConfiguration<DatabaseMigrationServiceClient>,
@@ -44,3 +46,16 @@ export const waitForReplicationInstanceDeleted = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until DMS replication instance is deleted.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeReplicationInstancesCommand for polling.
+ */
+export const waitUntilReplicationInstanceDeleted = async (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeReplicationInstancesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-database-migration-service/waiters/waitForReplicationTaskDeleted.ts b/clients/client-database-migration-service/waiters/waitForReplicationTaskDeleted.ts
index a15d68b63507e..a33f1afb6f2e9 100644
--- a/clients/client-database-migration-service/waiters/waitForReplicationTaskDeleted.ts
+++ b/clients/client-database-migration-service/waiters/waitForReplicationTaskDeleted.ts
@@ -3,14 +3,16 @@ import {
   DescribeReplicationTasksCommand,
   DescribeReplicationTasksCommandInput,
 } from "../commands/DescribeReplicationTasksCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: DatabaseMigrationServiceClient,
   input: DescribeReplicationTasksCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeReplicationTasksCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ReplicationTasks);
@@ -21,7 +23,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "ready") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -35,7 +37,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "creating") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -49,7 +51,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "stopped") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -63,7 +65,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "running") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -77,21 +79,21 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundFault") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until DMS replication task is deleted.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeReplicationTasksCommand for polling.
+ *  @deprecated Use waitUntilReplicationTaskDeleted instead. waitForReplicationTaskDeleted does not throw error in non-success cases.
  */
 export const waitForReplicationTaskDeleted = async (
   params: WaiterConfiguration<DatabaseMigrationServiceClient>,
@@ -100,3 +102,16 @@ export const waitForReplicationTaskDeleted = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until DMS replication task is deleted.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeReplicationTasksCommand for polling.
+ */
+export const waitUntilReplicationTaskDeleted = async (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeReplicationTasksCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-database-migration-service/waiters/waitForReplicationTaskReady.ts b/clients/client-database-migration-service/waiters/waitForReplicationTaskReady.ts
index 365c90805a5c3..859fbf47c0fa8 100644
--- a/clients/client-database-migration-service/waiters/waitForReplicationTaskReady.ts
+++ b/clients/client-database-migration-service/waiters/waitForReplicationTaskReady.ts
@@ -3,14 +3,16 @@ import {
   DescribeReplicationTasksCommand,
   DescribeReplicationTasksCommandInput,
 } from "../commands/DescribeReplicationTasksCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: DatabaseMigrationServiceClient,
   input: DescribeReplicationTasksCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeReplicationTasksCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ReplicationTasks);
@@ -24,7 +26,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "ready";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,7 +39,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "starting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -51,7 +53,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "running") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -65,7 +67,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "stopping") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -79,7 +81,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "stopped") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -93,7 +95,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -107,7 +109,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "modifying") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -121,7 +123,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "testing") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -135,17 +137,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until DMS replication task is ready.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeReplicationTasksCommand for polling.
+ *  @deprecated Use waitUntilReplicationTaskReady instead. waitForReplicationTaskReady does not throw error in non-success cases.
  */
 export const waitForReplicationTaskReady = async (
   params: WaiterConfiguration<DatabaseMigrationServiceClient>,
@@ -154,3 +157,16 @@ export const waitForReplicationTaskReady = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until DMS replication task is ready.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeReplicationTasksCommand for polling.
+ */
+export const waitUntilReplicationTaskReady = async (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeReplicationTasksCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-database-migration-service/waiters/waitForReplicationTaskRunning.ts b/clients/client-database-migration-service/waiters/waitForReplicationTaskRunning.ts
index bb04df18a7e5d..5bc65d39eb8e6 100644
--- a/clients/client-database-migration-service/waiters/waitForReplicationTaskRunning.ts
+++ b/clients/client-database-migration-service/waiters/waitForReplicationTaskRunning.ts
@@ -3,14 +3,16 @@ import {
   DescribeReplicationTasksCommand,
   DescribeReplicationTasksCommandInput,
 } from "../commands/DescribeReplicationTasksCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: DatabaseMigrationServiceClient,
   input: DescribeReplicationTasksCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeReplicationTasksCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ReplicationTasks);
@@ -24,7 +26,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "running";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,7 +39,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "ready") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -51,7 +53,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "creating") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -65,7 +67,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "stopping") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -79,7 +81,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "stopped") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -93,7 +95,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -107,7 +109,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "modifying") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -121,7 +123,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "testing") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -135,17 +137,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until DMS replication task is running.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeReplicationTasksCommand for polling.
+ *  @deprecated Use waitUntilReplicationTaskRunning instead. waitForReplicationTaskRunning does not throw error in non-success cases.
  */
 export const waitForReplicationTaskRunning = async (
   params: WaiterConfiguration<DatabaseMigrationServiceClient>,
@@ -154,3 +157,16 @@ export const waitForReplicationTaskRunning = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until DMS replication task is running.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeReplicationTasksCommand for polling.
+ */
+export const waitUntilReplicationTaskRunning = async (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeReplicationTasksCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-database-migration-service/waiters/waitForReplicationTaskStopped.ts b/clients/client-database-migration-service/waiters/waitForReplicationTaskStopped.ts
index 187bddbf68840..7f1dfd41996ed 100644
--- a/clients/client-database-migration-service/waiters/waitForReplicationTaskStopped.ts
+++ b/clients/client-database-migration-service/waiters/waitForReplicationTaskStopped.ts
@@ -3,14 +3,16 @@ import {
   DescribeReplicationTasksCommand,
   DescribeReplicationTasksCommandInput,
 } from "../commands/DescribeReplicationTasksCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: DatabaseMigrationServiceClient,
   input: DescribeReplicationTasksCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeReplicationTasksCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ReplicationTasks);
@@ -24,7 +26,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "stopped";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,7 +39,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "ready") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -51,7 +53,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "creating") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -65,7 +67,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "starting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -79,7 +81,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -93,7 +95,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "modifying") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -107,7 +109,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "testing") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -121,17 +123,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until DMS replication task is stopped.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeReplicationTasksCommand for polling.
+ *  @deprecated Use waitUntilReplicationTaskStopped instead. waitForReplicationTaskStopped does not throw error in non-success cases.
  */
 export const waitForReplicationTaskStopped = async (
   params: WaiterConfiguration<DatabaseMigrationServiceClient>,
@@ -140,3 +143,16 @@ export const waitForReplicationTaskStopped = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until DMS replication task is stopped.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeReplicationTasksCommand for polling.
+ */
+export const waitUntilReplicationTaskStopped = async (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeReplicationTasksCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-database-migration-service/waiters/waitForTestConnectionSucceeds.ts b/clients/client-database-migration-service/waiters/waitForTestConnectionSucceeds.ts
index a6033e154ec14..3b3d18dce0f5f 100644
--- a/clients/client-database-migration-service/waiters/waitForTestConnectionSucceeds.ts
+++ b/clients/client-database-migration-service/waiters/waitForTestConnectionSucceeds.ts
@@ -1,13 +1,15 @@
 import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
 import { DescribeConnectionsCommand, DescribeConnectionsCommandInput } from "../commands/DescribeConnectionsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: DatabaseMigrationServiceClient,
   input: DescribeConnectionsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeConnectionsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Connections);
@@ -21,7 +23,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "successful";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -34,17 +36,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until testing connection succeeds.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeConnectionsCommand for polling.
+ *  @deprecated Use waitUntilTestConnectionSucceeds instead. waitForTestConnectionSucceeds does not throw error in non-success cases.
  */
 export const waitForTestConnectionSucceeds = async (
   params: WaiterConfiguration<DatabaseMigrationServiceClient>,
@@ -53,3 +56,16 @@ export const waitForTestConnectionSucceeds = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until testing connection succeeds.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeConnectionsCommand for polling.
+ */
+export const waitUntilTestConnectionSucceeds = async (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeConnectionsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-docdb/waiters/waitForDBInstanceAvailable.ts b/clients/client-docdb/waiters/waitForDBInstanceAvailable.ts
index f4585ba8f5467..95baca8eecacf 100644
--- a/clients/client-docdb/waiters/waitForDBInstanceAvailable.ts
+++ b/clients/client-docdb/waiters/waitForDBInstanceAvailable.ts
@@ -1,10 +1,12 @@
 import { DocDBClient } from "../DocDBClient";
 import { DescribeDBInstancesCommand, DescribeDBInstancesCommandInput } from "../commands/DescribeDBInstancesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: DocDBClient, input: DescribeDBInstancesCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeDBInstancesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.DBInstances);
@@ -18,7 +20,7 @@ const checkState = async (client: DocDBClient, input: DescribeDBInstancesCommand
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: DocDBClient, input: DescribeDBInstancesCommand
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleted") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -45,7 +47,7 @@ const checkState = async (client: DocDBClient, input: DescribeDBInstancesCommand
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -59,7 +61,7 @@ const checkState = async (client: DocDBClient, input: DescribeDBInstancesCommand
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -73,7 +75,7 @@ const checkState = async (client: DocDBClient, input: DescribeDBInstancesCommand
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "incompatible-restore") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -87,17 +89,18 @@ const checkState = async (client: DocDBClient, input: DescribeDBInstancesCommand
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "incompatible-parameters") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeDBInstancesCommand for polling.
+ *  @deprecated Use waitUntilDBInstanceAvailable instead. waitForDBInstanceAvailable does not throw error in non-success cases.
  */
 export const waitForDBInstanceAvailable = async (
   params: WaiterConfiguration<DocDBClient>,
@@ -106,3 +109,16 @@ export const waitForDBInstanceAvailable = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeDBInstancesCommand for polling.
+ */
+export const waitUntilDBInstanceAvailable = async (
+  params: WaiterConfiguration<DocDBClient>,
+  input: DescribeDBInstancesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-dynamodb/waiters/waitForTableExists.ts b/clients/client-dynamodb/waiters/waitForTableExists.ts
index fc412f63061c4..ffa40b1eef822 100644
--- a/clients/client-dynamodb/waiters/waitForTableExists.ts
+++ b/clients/client-dynamodb/waiters/waitForTableExists.ts
@@ -1,29 +1,31 @@
 import { DynamoDBClient } from "../DynamoDBClient";
 import { DescribeTableCommand, DescribeTableCommandInput } from "../commands/DescribeTableCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: DynamoDBClient, input: DescribeTableCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeTableCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.Table.TableStatus;
       };
       if (returnComparator() === "ACTIVE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeTableCommand for polling.
+ *  @deprecated Use waitUntilTableExists instead. waitForTableExists does not throw error in non-success cases.
  */
 export const waitForTableExists = async (
   params: WaiterConfiguration<DynamoDBClient>,
@@ -32,3 +34,16 @@ export const waitForTableExists = async (
   const serviceDefaults = { minDelay: 20, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeTableCommand for polling.
+ */
+export const waitUntilTableExists = async (
+  params: WaiterConfiguration<DynamoDBClient>,
+  input: DescribeTableCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-dynamodb/waiters/waitForTableNotExists.ts b/clients/client-dynamodb/waiters/waitForTableNotExists.ts
index 06e39fdc1c0e2..e5daa9a2a0d82 100644
--- a/clients/client-dynamodb/waiters/waitForTableNotExists.ts
+++ b/clients/client-dynamodb/waiters/waitForTableNotExists.ts
@@ -1,21 +1,23 @@
 import { DynamoDBClient } from "../DynamoDBClient";
 import { DescribeTableCommand, DescribeTableCommandInput } from "../commands/DescribeTableCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: DynamoDBClient, input: DescribeTableCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeTableCommand(input));
+    reason = result;
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeTableCommand for polling.
+ *  @deprecated Use waitUntilTableNotExists instead. waitForTableNotExists does not throw error in non-success cases.
  */
 export const waitForTableNotExists = async (
   params: WaiterConfiguration<DynamoDBClient>,
@@ -24,3 +26,16 @@ export const waitForTableNotExists = async (
   const serviceDefaults = { minDelay: 20, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeTableCommand for polling.
+ */
+export const waitUntilTableNotExists = async (
+  params: WaiterConfiguration<DynamoDBClient>,
+  input: DescribeTableCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForBundleTaskComplete.ts b/clients/client-ec2/waiters/waitForBundleTaskComplete.ts
index 03433924df269..2aadd2544d180 100644
--- a/clients/client-ec2/waiters/waitForBundleTaskComplete.ts
+++ b/clients/client-ec2/waiters/waitForBundleTaskComplete.ts
@@ -1,10 +1,12 @@
 import { EC2Client } from "../EC2Client";
 import { DescribeBundleTasksCommand, DescribeBundleTasksCommandInput } from "../commands/DescribeBundleTasksCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeBundleTasksCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeBundleTasksCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.BundleTasks);
@@ -18,7 +20,7 @@ const checkState = async (client: EC2Client, input: DescribeBundleTasksCommandIn
         allStringEq_5 = allStringEq_5 && element_4 == "complete";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,17 +33,18 @@ const checkState = async (client: EC2Client, input: DescribeBundleTasksCommandIn
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeBundleTasksCommand for polling.
+ *  @deprecated Use waitUntilBundleTaskComplete instead. waitForBundleTaskComplete does not throw error in non-success cases.
  */
 export const waitForBundleTaskComplete = async (
   params: WaiterConfiguration<EC2Client>,
@@ -50,3 +53,16 @@ export const waitForBundleTaskComplete = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeBundleTasksCommand for polling.
+ */
+export const waitUntilBundleTaskComplete = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeBundleTasksCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForConversionTaskCancelled.ts b/clients/client-ec2/waiters/waitForConversionTaskCancelled.ts
index 9dd0ff9314e13..9bb8b9a2d4c45 100644
--- a/clients/client-ec2/waiters/waitForConversionTaskCancelled.ts
+++ b/clients/client-ec2/waiters/waitForConversionTaskCancelled.ts
@@ -3,11 +3,13 @@ import {
   DescribeConversionTasksCommand,
   DescribeConversionTasksCommandInput,
 } from "../commands/DescribeConversionTasksCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeConversionTasksCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeConversionTasksCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ConversionTasks);
@@ -21,16 +23,17 @@ const checkState = async (client: EC2Client, input: DescribeConversionTasksComma
         allStringEq_5 = allStringEq_5 && element_4 == "cancelled";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeConversionTasksCommand for polling.
+ *  @deprecated Use waitUntilConversionTaskCancelled instead. waitForConversionTaskCancelled does not throw error in non-success cases.
  */
 export const waitForConversionTaskCancelled = async (
   params: WaiterConfiguration<EC2Client>,
@@ -39,3 +42,16 @@ export const waitForConversionTaskCancelled = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeConversionTasksCommand for polling.
+ */
+export const waitUntilConversionTaskCancelled = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeConversionTasksCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForConversionTaskCompleted.ts b/clients/client-ec2/waiters/waitForConversionTaskCompleted.ts
index 24d7dbf32f442..270018c18540e 100644
--- a/clients/client-ec2/waiters/waitForConversionTaskCompleted.ts
+++ b/clients/client-ec2/waiters/waitForConversionTaskCompleted.ts
@@ -3,11 +3,13 @@ import {
   DescribeConversionTasksCommand,
   DescribeConversionTasksCommandInput,
 } from "../commands/DescribeConversionTasksCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeConversionTasksCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeConversionTasksCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ConversionTasks);
@@ -21,7 +23,7 @@ const checkState = async (client: EC2Client, input: DescribeConversionTasksComma
         allStringEq_5 = allStringEq_5 && element_4 == "completed";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -34,7 +36,7 @@ const checkState = async (client: EC2Client, input: DescribeConversionTasksComma
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "cancelled") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -48,17 +50,18 @@ const checkState = async (client: EC2Client, input: DescribeConversionTasksComma
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "cancelling") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeConversionTasksCommand for polling.
+ *  @deprecated Use waitUntilConversionTaskCompleted instead. waitForConversionTaskCompleted does not throw error in non-success cases.
  */
 export const waitForConversionTaskCompleted = async (
   params: WaiterConfiguration<EC2Client>,
@@ -67,3 +70,16 @@ export const waitForConversionTaskCompleted = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeConversionTasksCommand for polling.
+ */
+export const waitUntilConversionTaskCompleted = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeConversionTasksCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForConversionTaskDeleted.ts b/clients/client-ec2/waiters/waitForConversionTaskDeleted.ts
index 167984626d2ae..238eb722c14db 100644
--- a/clients/client-ec2/waiters/waitForConversionTaskDeleted.ts
+++ b/clients/client-ec2/waiters/waitForConversionTaskDeleted.ts
@@ -3,11 +3,13 @@ import {
   DescribeConversionTasksCommand,
   DescribeConversionTasksCommandInput,
 } from "../commands/DescribeConversionTasksCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeConversionTasksCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeConversionTasksCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ConversionTasks);
@@ -21,16 +23,17 @@ const checkState = async (client: EC2Client, input: DescribeConversionTasksComma
         allStringEq_5 = allStringEq_5 && element_4 == "deleted";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeConversionTasksCommand for polling.
+ *  @deprecated Use waitUntilConversionTaskDeleted instead. waitForConversionTaskDeleted does not throw error in non-success cases.
  */
 export const waitForConversionTaskDeleted = async (
   params: WaiterConfiguration<EC2Client>,
@@ -39,3 +42,16 @@ export const waitForConversionTaskDeleted = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeConversionTasksCommand for polling.
+ */
+export const waitUntilConversionTaskDeleted = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeConversionTasksCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForCustomerGatewayAvailable.ts b/clients/client-ec2/waiters/waitForCustomerGatewayAvailable.ts
index 7892cb4c3dfbe..ced4409b915c1 100644
--- a/clients/client-ec2/waiters/waitForCustomerGatewayAvailable.ts
+++ b/clients/client-ec2/waiters/waitForCustomerGatewayAvailable.ts
@@ -3,11 +3,13 @@ import {
   DescribeCustomerGatewaysCommand,
   DescribeCustomerGatewaysCommandInput,
 } from "../commands/DescribeCustomerGatewaysCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeCustomerGatewaysCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeCustomerGatewaysCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.CustomerGateways);
@@ -21,7 +23,7 @@ const checkState = async (client: EC2Client, input: DescribeCustomerGatewaysComm
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -34,7 +36,7 @@ const checkState = async (client: EC2Client, input: DescribeCustomerGatewaysComm
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleted") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -48,17 +50,18 @@ const checkState = async (client: EC2Client, input: DescribeCustomerGatewaysComm
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeCustomerGatewaysCommand for polling.
+ *  @deprecated Use waitUntilCustomerGatewayAvailable instead. waitForCustomerGatewayAvailable does not throw error in non-success cases.
  */
 export const waitForCustomerGatewayAvailable = async (
   params: WaiterConfiguration<EC2Client>,
@@ -67,3 +70,16 @@ export const waitForCustomerGatewayAvailable = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeCustomerGatewaysCommand for polling.
+ */
+export const waitUntilCustomerGatewayAvailable = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeCustomerGatewaysCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForExportTaskCancelled.ts b/clients/client-ec2/waiters/waitForExportTaskCancelled.ts
index 2b113dbbbca21..5b58beea73c73 100644
--- a/clients/client-ec2/waiters/waitForExportTaskCancelled.ts
+++ b/clients/client-ec2/waiters/waitForExportTaskCancelled.ts
@@ -1,10 +1,12 @@
 import { EC2Client } from "../EC2Client";
 import { DescribeExportTasksCommand, DescribeExportTasksCommandInput } from "../commands/DescribeExportTasksCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeExportTasksCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeExportTasksCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ExportTasks);
@@ -18,16 +20,17 @@ const checkState = async (client: EC2Client, input: DescribeExportTasksCommandIn
         allStringEq_5 = allStringEq_5 && element_4 == "cancelled";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeExportTasksCommand for polling.
+ *  @deprecated Use waitUntilExportTaskCancelled instead. waitForExportTaskCancelled does not throw error in non-success cases.
  */
 export const waitForExportTaskCancelled = async (
   params: WaiterConfiguration<EC2Client>,
@@ -36,3 +39,16 @@ export const waitForExportTaskCancelled = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeExportTasksCommand for polling.
+ */
+export const waitUntilExportTaskCancelled = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeExportTasksCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForExportTaskCompleted.ts b/clients/client-ec2/waiters/waitForExportTaskCompleted.ts
index dcbdddde3f4c1..aa216fc8beddf 100644
--- a/clients/client-ec2/waiters/waitForExportTaskCompleted.ts
+++ b/clients/client-ec2/waiters/waitForExportTaskCompleted.ts
@@ -1,10 +1,12 @@
 import { EC2Client } from "../EC2Client";
 import { DescribeExportTasksCommand, DescribeExportTasksCommandInput } from "../commands/DescribeExportTasksCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeExportTasksCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeExportTasksCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ExportTasks);
@@ -18,16 +20,17 @@ const checkState = async (client: EC2Client, input: DescribeExportTasksCommandIn
         allStringEq_5 = allStringEq_5 && element_4 == "completed";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeExportTasksCommand for polling.
+ *  @deprecated Use waitUntilExportTaskCompleted instead. waitForExportTaskCompleted does not throw error in non-success cases.
  */
 export const waitForExportTaskCompleted = async (
   params: WaiterConfiguration<EC2Client>,
@@ -36,3 +39,16 @@ export const waitForExportTaskCompleted = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeExportTasksCommand for polling.
+ */
+export const waitUntilExportTaskCompleted = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeExportTasksCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForImageAvailable.ts b/clients/client-ec2/waiters/waitForImageAvailable.ts
index 048f2565a336c..3f5e37a689843 100644
--- a/clients/client-ec2/waiters/waitForImageAvailable.ts
+++ b/clients/client-ec2/waiters/waitForImageAvailable.ts
@@ -1,10 +1,12 @@
 import { EC2Client } from "../EC2Client";
 import { DescribeImagesCommand, DescribeImagesCommandInput } from "../commands/DescribeImagesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeImagesCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeImagesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Images);
@@ -18,7 +20,7 @@ const checkState = async (client: EC2Client, input: DescribeImagesCommandInput):
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,17 +33,18 @@ const checkState = async (client: EC2Client, input: DescribeImagesCommandInput):
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeImagesCommand for polling.
+ *  @deprecated Use waitUntilImageAvailable instead. waitForImageAvailable does not throw error in non-success cases.
  */
 export const waitForImageAvailable = async (
   params: WaiterConfiguration<EC2Client>,
@@ -50,3 +53,16 @@ export const waitForImageAvailable = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeImagesCommand for polling.
+ */
+export const waitUntilImageAvailable = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeImagesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForInstanceStopped.ts b/clients/client-ec2/waiters/waitForInstanceStopped.ts
index df2798991f131..7c498d8dd23e2 100644
--- a/clients/client-ec2/waiters/waitForInstanceStopped.ts
+++ b/clients/client-ec2/waiters/waitForInstanceStopped.ts
@@ -1,10 +1,12 @@
 import { EC2Client } from "../EC2Client";
 import { DescribeInstancesCommand, DescribeInstancesCommandInput } from "../commands/DescribeInstancesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeInstancesCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeInstancesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Reservations);
@@ -22,7 +24,7 @@ const checkState = async (client: EC2Client, input: DescribeInstancesCommandInpu
         allStringEq_8 = allStringEq_8 && element_7 == "stopped";
       }
       if (allStringEq_8) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -39,7 +41,7 @@ const checkState = async (client: EC2Client, input: DescribeInstancesCommandInpu
       };
       for (let anyStringEq_7 of returnComparator()) {
         if (anyStringEq_7 == "pending") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -57,17 +59,18 @@ const checkState = async (client: EC2Client, input: DescribeInstancesCommandInpu
       };
       for (let anyStringEq_7 of returnComparator()) {
         if (anyStringEq_7 == "terminated") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeInstancesCommand for polling.
+ *  @deprecated Use waitUntilInstanceStopped instead. waitForInstanceStopped does not throw error in non-success cases.
  */
 export const waitForInstanceStopped = async (
   params: WaiterConfiguration<EC2Client>,
@@ -76,3 +79,16 @@ export const waitForInstanceStopped = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeInstancesCommand for polling.
+ */
+export const waitUntilInstanceStopped = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeInstancesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForInstanceTerminated.ts b/clients/client-ec2/waiters/waitForInstanceTerminated.ts
index a9c29c72d66d7..12e61240c537c 100644
--- a/clients/client-ec2/waiters/waitForInstanceTerminated.ts
+++ b/clients/client-ec2/waiters/waitForInstanceTerminated.ts
@@ -1,10 +1,12 @@
 import { EC2Client } from "../EC2Client";
 import { DescribeInstancesCommand, DescribeInstancesCommandInput } from "../commands/DescribeInstancesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeInstancesCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeInstancesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Reservations);
@@ -22,7 +24,7 @@ const checkState = async (client: EC2Client, input: DescribeInstancesCommandInpu
         allStringEq_8 = allStringEq_8 && element_7 == "terminated";
       }
       if (allStringEq_8) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -39,7 +41,7 @@ const checkState = async (client: EC2Client, input: DescribeInstancesCommandInpu
       };
       for (let anyStringEq_7 of returnComparator()) {
         if (anyStringEq_7 == "pending") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -57,17 +59,18 @@ const checkState = async (client: EC2Client, input: DescribeInstancesCommandInpu
       };
       for (let anyStringEq_7 of returnComparator()) {
         if (anyStringEq_7 == "stopping") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeInstancesCommand for polling.
+ *  @deprecated Use waitUntilInstanceTerminated instead. waitForInstanceTerminated does not throw error in non-success cases.
  */
 export const waitForInstanceTerminated = async (
   params: WaiterConfiguration<EC2Client>,
@@ -76,3 +79,16 @@ export const waitForInstanceTerminated = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeInstancesCommand for polling.
+ */
+export const waitUntilInstanceTerminated = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeInstancesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForPasswordDataAvailable.ts b/clients/client-ec2/waiters/waitForPasswordDataAvailable.ts
index 3f484bf93e3b1..6152c7b25b82d 100644
--- a/clients/client-ec2/waiters/waitForPasswordDataAvailable.ts
+++ b/clients/client-ec2/waiters/waitForPasswordDataAvailable.ts
@@ -1,25 +1,28 @@
 import { EC2Client } from "../EC2Client";
 import { GetPasswordDataCommand, GetPasswordDataCommandInput } from "../commands/GetPasswordDataCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: GetPasswordDataCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetPasswordDataCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.PasswordData.length > 0.0;
       };
       if (returnComparator() == true) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetPasswordDataCommand for polling.
+ *  @deprecated Use waitUntilPasswordDataAvailable instead. waitForPasswordDataAvailable does not throw error in non-success cases.
  */
 export const waitForPasswordDataAvailable = async (
   params: WaiterConfiguration<EC2Client>,
@@ -28,3 +31,16 @@ export const waitForPasswordDataAvailable = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetPasswordDataCommand for polling.
+ */
+export const waitUntilPasswordDataAvailable = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: GetPasswordDataCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForSnapshotCompleted.ts b/clients/client-ec2/waiters/waitForSnapshotCompleted.ts
index f9b37a2e1672c..0549d18b03363 100644
--- a/clients/client-ec2/waiters/waitForSnapshotCompleted.ts
+++ b/clients/client-ec2/waiters/waitForSnapshotCompleted.ts
@@ -1,10 +1,12 @@
 import { EC2Client } from "../EC2Client";
 import { DescribeSnapshotsCommand, DescribeSnapshotsCommandInput } from "../commands/DescribeSnapshotsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeSnapshotsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeSnapshotsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Snapshots);
@@ -18,16 +20,17 @@ const checkState = async (client: EC2Client, input: DescribeSnapshotsCommandInpu
         allStringEq_5 = allStringEq_5 && element_4 == "completed";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeSnapshotsCommand for polling.
+ *  @deprecated Use waitUntilSnapshotCompleted instead. waitForSnapshotCompleted does not throw error in non-success cases.
  */
 export const waitForSnapshotCompleted = async (
   params: WaiterConfiguration<EC2Client>,
@@ -36,3 +39,16 @@ export const waitForSnapshotCompleted = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeSnapshotsCommand for polling.
+ */
+export const waitUntilSnapshotCompleted = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeSnapshotsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForSubnetAvailable.ts b/clients/client-ec2/waiters/waitForSubnetAvailable.ts
index 6a70a1cf6dc65..0beb623bd0b54 100644
--- a/clients/client-ec2/waiters/waitForSubnetAvailable.ts
+++ b/clients/client-ec2/waiters/waitForSubnetAvailable.ts
@@ -1,10 +1,12 @@
 import { EC2Client } from "../EC2Client";
 import { DescribeSubnetsCommand, DescribeSubnetsCommandInput } from "../commands/DescribeSubnetsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeSubnetsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeSubnetsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Subnets);
@@ -18,16 +20,17 @@ const checkState = async (client: EC2Client, input: DescribeSubnetsCommandInput)
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeSubnetsCommand for polling.
+ *  @deprecated Use waitUntilSubnetAvailable instead. waitForSubnetAvailable does not throw error in non-success cases.
  */
 export const waitForSubnetAvailable = async (
   params: WaiterConfiguration<EC2Client>,
@@ -36,3 +39,16 @@ export const waitForSubnetAvailable = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeSubnetsCommand for polling.
+ */
+export const waitUntilSubnetAvailable = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeSubnetsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForSystemStatusOk.ts b/clients/client-ec2/waiters/waitForSystemStatusOk.ts
index 6c5fd4056aada..cc96647ef586e 100644
--- a/clients/client-ec2/waiters/waitForSystemStatusOk.ts
+++ b/clients/client-ec2/waiters/waitForSystemStatusOk.ts
@@ -3,11 +3,13 @@ import {
   DescribeInstanceStatusCommand,
   DescribeInstanceStatusCommandInput,
 } from "../commands/DescribeInstanceStatusCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeInstanceStatusCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeInstanceStatusCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.InstanceStatuses);
@@ -21,16 +23,17 @@ const checkState = async (client: EC2Client, input: DescribeInstanceStatusComman
         allStringEq_5 = allStringEq_5 && element_4 == "ok";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeInstanceStatusCommand for polling.
+ *  @deprecated Use waitUntilSystemStatusOk instead. waitForSystemStatusOk does not throw error in non-success cases.
  */
 export const waitForSystemStatusOk = async (
   params: WaiterConfiguration<EC2Client>,
@@ -39,3 +42,16 @@ export const waitForSystemStatusOk = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeInstanceStatusCommand for polling.
+ */
+export const waitUntilSystemStatusOk = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeInstanceStatusCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForVolumeAvailable.ts b/clients/client-ec2/waiters/waitForVolumeAvailable.ts
index de8d46a65e848..67548540834bc 100644
--- a/clients/client-ec2/waiters/waitForVolumeAvailable.ts
+++ b/clients/client-ec2/waiters/waitForVolumeAvailable.ts
@@ -1,10 +1,12 @@
 import { EC2Client } from "../EC2Client";
 import { DescribeVolumesCommand, DescribeVolumesCommandInput } from "../commands/DescribeVolumesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeVolumesCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeVolumesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Volumes);
@@ -18,7 +20,7 @@ const checkState = async (client: EC2Client, input: DescribeVolumesCommandInput)
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,17 +33,18 @@ const checkState = async (client: EC2Client, input: DescribeVolumesCommandInput)
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleted") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeVolumesCommand for polling.
+ *  @deprecated Use waitUntilVolumeAvailable instead. waitForVolumeAvailable does not throw error in non-success cases.
  */
 export const waitForVolumeAvailable = async (
   params: WaiterConfiguration<EC2Client>,
@@ -50,3 +53,16 @@ export const waitForVolumeAvailable = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeVolumesCommand for polling.
+ */
+export const waitUntilVolumeAvailable = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeVolumesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForVolumeInUse.ts b/clients/client-ec2/waiters/waitForVolumeInUse.ts
index bafe452cfca60..6970b1da70983 100644
--- a/clients/client-ec2/waiters/waitForVolumeInUse.ts
+++ b/clients/client-ec2/waiters/waitForVolumeInUse.ts
@@ -1,10 +1,12 @@
 import { EC2Client } from "../EC2Client";
 import { DescribeVolumesCommand, DescribeVolumesCommandInput } from "../commands/DescribeVolumesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeVolumesCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeVolumesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Volumes);
@@ -18,7 +20,7 @@ const checkState = async (client: EC2Client, input: DescribeVolumesCommandInput)
         allStringEq_5 = allStringEq_5 && element_4 == "in-use";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,17 +33,18 @@ const checkState = async (client: EC2Client, input: DescribeVolumesCommandInput)
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleted") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeVolumesCommand for polling.
+ *  @deprecated Use waitUntilVolumeInUse instead. waitForVolumeInUse does not throw error in non-success cases.
  */
 export const waitForVolumeInUse = async (
   params: WaiterConfiguration<EC2Client>,
@@ -50,3 +53,16 @@ export const waitForVolumeInUse = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeVolumesCommand for polling.
+ */
+export const waitUntilVolumeInUse = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeVolumesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForVpcAvailable.ts b/clients/client-ec2/waiters/waitForVpcAvailable.ts
index 71443f352c395..f34a1ce146991 100644
--- a/clients/client-ec2/waiters/waitForVpcAvailable.ts
+++ b/clients/client-ec2/waiters/waitForVpcAvailable.ts
@@ -1,10 +1,12 @@
 import { EC2Client } from "../EC2Client";
 import { DescribeVpcsCommand, DescribeVpcsCommandInput } from "../commands/DescribeVpcsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeVpcsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeVpcsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Vpcs);
@@ -18,16 +20,17 @@ const checkState = async (client: EC2Client, input: DescribeVpcsCommandInput): P
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeVpcsCommand for polling.
+ *  @deprecated Use waitUntilVpcAvailable instead. waitForVpcAvailable does not throw error in non-success cases.
  */
 export const waitForVpcAvailable = async (
   params: WaiterConfiguration<EC2Client>,
@@ -36,3 +39,16 @@ export const waitForVpcAvailable = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeVpcsCommand for polling.
+ */
+export const waitUntilVpcAvailable = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeVpcsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForVpnConnectionAvailable.ts b/clients/client-ec2/waiters/waitForVpnConnectionAvailable.ts
index 178d562120b08..a9f1c0ecef07c 100644
--- a/clients/client-ec2/waiters/waitForVpnConnectionAvailable.ts
+++ b/clients/client-ec2/waiters/waitForVpnConnectionAvailable.ts
@@ -3,11 +3,13 @@ import {
   DescribeVpnConnectionsCommand,
   DescribeVpnConnectionsCommandInput,
 } from "../commands/DescribeVpnConnectionsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeVpnConnectionsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeVpnConnectionsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.VpnConnections);
@@ -21,7 +23,7 @@ const checkState = async (client: EC2Client, input: DescribeVpnConnectionsComman
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -34,7 +36,7 @@ const checkState = async (client: EC2Client, input: DescribeVpnConnectionsComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -48,17 +50,18 @@ const checkState = async (client: EC2Client, input: DescribeVpnConnectionsComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleted") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeVpnConnectionsCommand for polling.
+ *  @deprecated Use waitUntilVpnConnectionAvailable instead. waitForVpnConnectionAvailable does not throw error in non-success cases.
  */
 export const waitForVpnConnectionAvailable = async (
   params: WaiterConfiguration<EC2Client>,
@@ -67,3 +70,16 @@ export const waitForVpnConnectionAvailable = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeVpnConnectionsCommand for polling.
+ */
+export const waitUntilVpnConnectionAvailable = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeVpnConnectionsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ec2/waiters/waitForVpnConnectionDeleted.ts b/clients/client-ec2/waiters/waitForVpnConnectionDeleted.ts
index 9e4ca72a426ce..a9d988af34195 100644
--- a/clients/client-ec2/waiters/waitForVpnConnectionDeleted.ts
+++ b/clients/client-ec2/waiters/waitForVpnConnectionDeleted.ts
@@ -3,11 +3,13 @@ import {
   DescribeVpnConnectionsCommand,
   DescribeVpnConnectionsCommandInput,
 } from "../commands/DescribeVpnConnectionsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EC2Client, input: DescribeVpnConnectionsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeVpnConnectionsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.VpnConnections);
@@ -21,7 +23,7 @@ const checkState = async (client: EC2Client, input: DescribeVpnConnectionsComman
         allStringEq_5 = allStringEq_5 && element_4 == "deleted";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -34,17 +36,18 @@ const checkState = async (client: EC2Client, input: DescribeVpnConnectionsComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "pending") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeVpnConnectionsCommand for polling.
+ *  @deprecated Use waitUntilVpnConnectionDeleted instead. waitForVpnConnectionDeleted does not throw error in non-success cases.
  */
 export const waitForVpnConnectionDeleted = async (
   params: WaiterConfiguration<EC2Client>,
@@ -53,3 +56,16 @@ export const waitForVpnConnectionDeleted = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeVpnConnectionsCommand for polling.
+ */
+export const waitUntilVpnConnectionDeleted = async (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeVpnConnectionsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ecr/waiters/waitForImageScanComplete.ts b/clients/client-ecr/waiters/waitForImageScanComplete.ts
index f401504cdc044..f67fc9bbc01cf 100644
--- a/clients/client-ecr/waiters/waitForImageScanComplete.ts
+++ b/clients/client-ecr/waiters/waitForImageScanComplete.ts
@@ -3,17 +3,19 @@ import {
   DescribeImageScanFindingsCommand,
   DescribeImageScanFindingsCommandInput,
 } from "../commands/DescribeImageScanFindingsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: ECRClient, input: DescribeImageScanFindingsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeImageScanFindingsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.imageScanStatus.status;
       };
       if (returnComparator() === "COMPLETE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -21,16 +23,17 @@ const checkState = async (client: ECRClient, input: DescribeImageScanFindingsCom
         return result.imageScanStatus.status;
       };
       if (returnComparator() === "FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until an image scan is complete and findings can be accessed
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeImageScanFindingsCommand for polling.
+ *  @deprecated Use waitUntilImageScanComplete instead. waitForImageScanComplete does not throw error in non-success cases.
  */
 export const waitForImageScanComplete = async (
   params: WaiterConfiguration<ECRClient>,
@@ -39,3 +42,16 @@ export const waitForImageScanComplete = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until an image scan is complete and findings can be accessed
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeImageScanFindingsCommand for polling.
+ */
+export const waitUntilImageScanComplete = async (
+  params: WaiterConfiguration<ECRClient>,
+  input: DescribeImageScanFindingsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ecr/waiters/waitForLifecyclePolicyPreviewComplete.ts b/clients/client-ecr/waiters/waitForLifecyclePolicyPreviewComplete.ts
index de94ca2bb8102..669c72c874ecd 100644
--- a/clients/client-ecr/waiters/waitForLifecyclePolicyPreviewComplete.ts
+++ b/clients/client-ecr/waiters/waitForLifecyclePolicyPreviewComplete.ts
@@ -3,17 +3,19 @@ import {
   GetLifecyclePolicyPreviewCommand,
   GetLifecyclePolicyPreviewCommandInput,
 } from "../commands/GetLifecyclePolicyPreviewCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: ECRClient, input: GetLifecyclePolicyPreviewCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetLifecyclePolicyPreviewCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.status;
       };
       if (returnComparator() === "COMPLETE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -21,16 +23,17 @@ const checkState = async (client: ECRClient, input: GetLifecyclePolicyPreviewCom
         return result.status;
       };
       if (returnComparator() === "FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a lifecycle policy preview request is complete and results can be accessed
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetLifecyclePolicyPreviewCommand for polling.
+ *  @deprecated Use waitUntilLifecyclePolicyPreviewComplete instead. waitForLifecyclePolicyPreviewComplete does not throw error in non-success cases.
  */
 export const waitForLifecyclePolicyPreviewComplete = async (
   params: WaiterConfiguration<ECRClient>,
@@ -39,3 +42,16 @@ export const waitForLifecyclePolicyPreviewComplete = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a lifecycle policy preview request is complete and results can be accessed
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetLifecyclePolicyPreviewCommand for polling.
+ */
+export const waitUntilLifecyclePolicyPreviewComplete = async (
+  params: WaiterConfiguration<ECRClient>,
+  input: GetLifecyclePolicyPreviewCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ecs/waiters/waitForServicesInactive.ts b/clients/client-ecs/waiters/waitForServicesInactive.ts
index 3ac83c45f447d..c11de6044765b 100644
--- a/clients/client-ecs/waiters/waitForServicesInactive.ts
+++ b/clients/client-ecs/waiters/waitForServicesInactive.ts
@@ -1,10 +1,12 @@
 import { ECSClient } from "../ECSClient";
 import { DescribeServicesCommand, DescribeServicesCommandInput } from "../commands/DescribeServicesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: ECSClient, input: DescribeServicesCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeServicesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.failures);
@@ -15,7 +17,7 @@ const checkState = async (client: ECSClient, input: DescribeServicesCommandInput
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "MISSING") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -29,17 +31,18 @@ const checkState = async (client: ECSClient, input: DescribeServicesCommandInput
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "INACTIVE") {
-          return { state: WaiterState.SUCCESS };
+          return { state: WaiterState.SUCCESS, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeServicesCommand for polling.
+ *  @deprecated Use waitUntilServicesInactive instead. waitForServicesInactive does not throw error in non-success cases.
  */
 export const waitForServicesInactive = async (
   params: WaiterConfiguration<ECSClient>,
@@ -48,3 +51,16 @@ export const waitForServicesInactive = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeServicesCommand for polling.
+ */
+export const waitUntilServicesInactive = async (
+  params: WaiterConfiguration<ECSClient>,
+  input: DescribeServicesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ecs/waiters/waitForTasksRunning.ts b/clients/client-ecs/waiters/waitForTasksRunning.ts
index dc6b7f175ab6c..aaeb4b0171cbe 100644
--- a/clients/client-ecs/waiters/waitForTasksRunning.ts
+++ b/clients/client-ecs/waiters/waitForTasksRunning.ts
@@ -1,10 +1,12 @@
 import { ECSClient } from "../ECSClient";
 import { DescribeTasksCommand, DescribeTasksCommandInput } from "../commands/DescribeTasksCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: ECSClient, input: DescribeTasksCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeTasksCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.tasks);
@@ -15,7 +17,7 @@ const checkState = async (client: ECSClient, input: DescribeTasksCommandInput):
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "STOPPED") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -29,7 +31,7 @@ const checkState = async (client: ECSClient, input: DescribeTasksCommandInput):
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "MISSING") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -46,16 +48,17 @@ const checkState = async (client: ECSClient, input: DescribeTasksCommandInput):
         allStringEq_5 = allStringEq_5 && element_4 == "RUNNING";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeTasksCommand for polling.
+ *  @deprecated Use waitUntilTasksRunning instead. waitForTasksRunning does not throw error in non-success cases.
  */
 export const waitForTasksRunning = async (
   params: WaiterConfiguration<ECSClient>,
@@ -64,3 +67,16 @@ export const waitForTasksRunning = async (
   const serviceDefaults = { minDelay: 6, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeTasksCommand for polling.
+ */
+export const waitUntilTasksRunning = async (
+  params: WaiterConfiguration<ECSClient>,
+  input: DescribeTasksCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 6, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ecs/waiters/waitForTasksStopped.ts b/clients/client-ecs/waiters/waitForTasksStopped.ts
index f1072768e7a51..99089aec2c46d 100644
--- a/clients/client-ecs/waiters/waitForTasksStopped.ts
+++ b/clients/client-ecs/waiters/waitForTasksStopped.ts
@@ -1,10 +1,12 @@
 import { ECSClient } from "../ECSClient";
 import { DescribeTasksCommand, DescribeTasksCommandInput } from "../commands/DescribeTasksCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: ECSClient, input: DescribeTasksCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeTasksCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.tasks);
@@ -18,16 +20,17 @@ const checkState = async (client: ECSClient, input: DescribeTasksCommandInput):
         allStringEq_5 = allStringEq_5 && element_4 == "STOPPED";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeTasksCommand for polling.
+ *  @deprecated Use waitUntilTasksStopped instead. waitForTasksStopped does not throw error in non-success cases.
  */
 export const waitForTasksStopped = async (
   params: WaiterConfiguration<ECSClient>,
@@ -36,3 +39,16 @@ export const waitForTasksStopped = async (
   const serviceDefaults = { minDelay: 6, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeTasksCommand for polling.
+ */
+export const waitUntilTasksStopped = async (
+  params: WaiterConfiguration<ECSClient>,
+  input: DescribeTasksCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 6, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-eks/waiters/waitForAddonActive.ts b/clients/client-eks/waiters/waitForAddonActive.ts
index f384df0c05028..5e0672404ebbe 100644
--- a/clients/client-eks/waiters/waitForAddonActive.ts
+++ b/clients/client-eks/waiters/waitForAddonActive.ts
@@ -1,16 +1,18 @@
 import { EKSClient } from "../EKSClient";
 import { DescribeAddonCommand, DescribeAddonCommandInput } from "../commands/DescribeAddonCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EKSClient, input: DescribeAddonCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeAddonCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.addon.status;
       };
       if (returnComparator() === "CREATE_FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -18,16 +20,17 @@ const checkState = async (client: EKSClient, input: DescribeAddonCommandInput):
         return result.addon.status;
       };
       if (returnComparator() === "ACTIVE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeAddonCommand for polling.
+ *  @deprecated Use waitUntilAddonActive instead. waitForAddonActive does not throw error in non-success cases.
  */
 export const waitForAddonActive = async (
   params: WaiterConfiguration<EKSClient>,
@@ -36,3 +39,16 @@ export const waitForAddonActive = async (
   const serviceDefaults = { minDelay: 10, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeAddonCommand for polling.
+ */
+export const waitUntilAddonActive = async (
+  params: WaiterConfiguration<EKSClient>,
+  input: DescribeAddonCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-eks/waiters/waitForAddonDeleted.ts b/clients/client-eks/waiters/waitForAddonDeleted.ts
index 83284e5288c91..fda2297ec7039 100644
--- a/clients/client-eks/waiters/waitForAddonDeleted.ts
+++ b/clients/client-eks/waiters/waitForAddonDeleted.ts
@@ -1,29 +1,31 @@
 import { EKSClient } from "../EKSClient";
 import { DescribeAddonCommand, DescribeAddonCommandInput } from "../commands/DescribeAddonCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EKSClient, input: DescribeAddonCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeAddonCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.addon.status;
       };
       if (returnComparator() === "DELETE_FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeAddonCommand for polling.
+ *  @deprecated Use waitUntilAddonDeleted instead. waitForAddonDeleted does not throw error in non-success cases.
  */
 export const waitForAddonDeleted = async (
   params: WaiterConfiguration<EKSClient>,
@@ -32,3 +34,16 @@ export const waitForAddonDeleted = async (
   const serviceDefaults = { minDelay: 10, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeAddonCommand for polling.
+ */
+export const waitUntilAddonDeleted = async (
+  params: WaiterConfiguration<EKSClient>,
+  input: DescribeAddonCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-eks/waiters/waitForClusterActive.ts b/clients/client-eks/waiters/waitForClusterActive.ts
index f0edcbc8140a8..6f2dc58eba89c 100644
--- a/clients/client-eks/waiters/waitForClusterActive.ts
+++ b/clients/client-eks/waiters/waitForClusterActive.ts
@@ -1,16 +1,18 @@
 import { EKSClient } from "../EKSClient";
 import { DescribeClusterCommand, DescribeClusterCommandInput } from "../commands/DescribeClusterCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EKSClient, input: DescribeClusterCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeClusterCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.cluster.status;
       };
       if (returnComparator() === "DELETING") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -18,7 +20,7 @@ const checkState = async (client: EKSClient, input: DescribeClusterCommandInput)
         return result.cluster.status;
       };
       if (returnComparator() === "FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -26,16 +28,17 @@ const checkState = async (client: EKSClient, input: DescribeClusterCommandInput)
         return result.cluster.status;
       };
       if (returnComparator() === "ACTIVE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeClusterCommand for polling.
+ *  @deprecated Use waitUntilClusterActive instead. waitForClusterActive does not throw error in non-success cases.
  */
 export const waitForClusterActive = async (
   params: WaiterConfiguration<EKSClient>,
@@ -44,3 +47,16 @@ export const waitForClusterActive = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeClusterCommand for polling.
+ */
+export const waitUntilClusterActive = async (
+  params: WaiterConfiguration<EKSClient>,
+  input: DescribeClusterCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-eks/waiters/waitForClusterDeleted.ts b/clients/client-eks/waiters/waitForClusterDeleted.ts
index 571219981f547..bbb641afcb5df 100644
--- a/clients/client-eks/waiters/waitForClusterDeleted.ts
+++ b/clients/client-eks/waiters/waitForClusterDeleted.ts
@@ -1,16 +1,18 @@
 import { EKSClient } from "../EKSClient";
 import { DescribeClusterCommand, DescribeClusterCommandInput } from "../commands/DescribeClusterCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EKSClient, input: DescribeClusterCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeClusterCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.cluster.status;
       };
       if (returnComparator() === "ACTIVE") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -18,20 +20,20 @@ const checkState = async (client: EKSClient, input: DescribeClusterCommandInput)
         return result.cluster.status;
       };
       if (returnComparator() === "CREATING") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeClusterCommand for polling.
+ *  @deprecated Use waitUntilClusterDeleted instead. waitForClusterDeleted does not throw error in non-success cases.
  */
 export const waitForClusterDeleted = async (
   params: WaiterConfiguration<EKSClient>,
@@ -40,3 +42,16 @@ export const waitForClusterDeleted = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeClusterCommand for polling.
+ */
+export const waitUntilClusterDeleted = async (
+  params: WaiterConfiguration<EKSClient>,
+  input: DescribeClusterCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-eks/waiters/waitForNodegroupActive.ts b/clients/client-eks/waiters/waitForNodegroupActive.ts
index 75f83a5ecbc16..a8c7d72c3a9a9 100644
--- a/clients/client-eks/waiters/waitForNodegroupActive.ts
+++ b/clients/client-eks/waiters/waitForNodegroupActive.ts
@@ -1,16 +1,18 @@
 import { EKSClient } from "../EKSClient";
 import { DescribeNodegroupCommand, DescribeNodegroupCommandInput } from "../commands/DescribeNodegroupCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EKSClient, input: DescribeNodegroupCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeNodegroupCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.nodegroup.status;
       };
       if (returnComparator() === "CREATE_FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -18,16 +20,17 @@ const checkState = async (client: EKSClient, input: DescribeNodegroupCommandInpu
         return result.nodegroup.status;
       };
       if (returnComparator() === "ACTIVE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeNodegroupCommand for polling.
+ *  @deprecated Use waitUntilNodegroupActive instead. waitForNodegroupActive does not throw error in non-success cases.
  */
 export const waitForNodegroupActive = async (
   params: WaiterConfiguration<EKSClient>,
@@ -36,3 +39,16 @@ export const waitForNodegroupActive = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeNodegroupCommand for polling.
+ */
+export const waitUntilNodegroupActive = async (
+  params: WaiterConfiguration<EKSClient>,
+  input: DescribeNodegroupCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-eks/waiters/waitForNodegroupDeleted.ts b/clients/client-eks/waiters/waitForNodegroupDeleted.ts
index 382460d00b6ea..328cbd9d4c563 100644
--- a/clients/client-eks/waiters/waitForNodegroupDeleted.ts
+++ b/clients/client-eks/waiters/waitForNodegroupDeleted.ts
@@ -1,29 +1,31 @@
 import { EKSClient } from "../EKSClient";
 import { DescribeNodegroupCommand, DescribeNodegroupCommandInput } from "../commands/DescribeNodegroupCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EKSClient, input: DescribeNodegroupCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeNodegroupCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.nodegroup.status;
       };
       if (returnComparator() === "DELETE_FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeNodegroupCommand for polling.
+ *  @deprecated Use waitUntilNodegroupDeleted instead. waitForNodegroupDeleted does not throw error in non-success cases.
  */
 export const waitForNodegroupDeleted = async (
   params: WaiterConfiguration<EKSClient>,
@@ -32,3 +34,16 @@ export const waitForNodegroupDeleted = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeNodegroupCommand for polling.
+ */
+export const waitUntilNodegroupDeleted = async (
+  params: WaiterConfiguration<EKSClient>,
+  input: DescribeNodegroupCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-elastic-beanstalk/waiters/waitForEnvironmentExists.ts b/clients/client-elastic-beanstalk/waiters/waitForEnvironmentExists.ts
index 40d3fb6ebf750..0492f51a49b5f 100644
--- a/clients/client-elastic-beanstalk/waiters/waitForEnvironmentExists.ts
+++ b/clients/client-elastic-beanstalk/waiters/waitForEnvironmentExists.ts
@@ -1,13 +1,15 @@
 import { ElasticBeanstalkClient } from "../ElasticBeanstalkClient";
 import { DescribeEnvironmentsCommand, DescribeEnvironmentsCommandInput } from "../commands/DescribeEnvironmentsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: ElasticBeanstalkClient,
   input: DescribeEnvironmentsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeEnvironmentsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Environments);
@@ -21,7 +23,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "Ready";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,16 +39,17 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "Launching";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeEnvironmentsCommand for polling.
+ *  @deprecated Use waitUntilEnvironmentExists instead. waitForEnvironmentExists does not throw error in non-success cases.
  */
 export const waitForEnvironmentExists = async (
   params: WaiterConfiguration<ElasticBeanstalkClient>,
@@ -55,3 +58,16 @@ export const waitForEnvironmentExists = async (
   const serviceDefaults = { minDelay: 20, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeEnvironmentsCommand for polling.
+ */
+export const waitUntilEnvironmentExists = async (
+  params: WaiterConfiguration<ElasticBeanstalkClient>,
+  input: DescribeEnvironmentsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-elastic-beanstalk/waiters/waitForEnvironmentTerminated.ts b/clients/client-elastic-beanstalk/waiters/waitForEnvironmentTerminated.ts
index da4ec397d7ddc..bcc0a4406a16e 100644
--- a/clients/client-elastic-beanstalk/waiters/waitForEnvironmentTerminated.ts
+++ b/clients/client-elastic-beanstalk/waiters/waitForEnvironmentTerminated.ts
@@ -1,13 +1,15 @@
 import { ElasticBeanstalkClient } from "../ElasticBeanstalkClient";
 import { DescribeEnvironmentsCommand, DescribeEnvironmentsCommandInput } from "../commands/DescribeEnvironmentsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: ElasticBeanstalkClient,
   input: DescribeEnvironmentsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeEnvironmentsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Environments);
@@ -21,7 +23,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "Terminated";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,16 +39,17 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "Terminating";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeEnvironmentsCommand for polling.
+ *  @deprecated Use waitUntilEnvironmentTerminated instead. waitForEnvironmentTerminated does not throw error in non-success cases.
  */
 export const waitForEnvironmentTerminated = async (
   params: WaiterConfiguration<ElasticBeanstalkClient>,
@@ -55,3 +58,16 @@ export const waitForEnvironmentTerminated = async (
   const serviceDefaults = { minDelay: 20, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeEnvironmentsCommand for polling.
+ */
+export const waitUntilEnvironmentTerminated = async (
+  params: WaiterConfiguration<ElasticBeanstalkClient>,
+  input: DescribeEnvironmentsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-elastic-beanstalk/waiters/waitForEnvironmentUpdated.ts b/clients/client-elastic-beanstalk/waiters/waitForEnvironmentUpdated.ts
index 683aa99e80221..30efcddb594e3 100644
--- a/clients/client-elastic-beanstalk/waiters/waitForEnvironmentUpdated.ts
+++ b/clients/client-elastic-beanstalk/waiters/waitForEnvironmentUpdated.ts
@@ -1,13 +1,15 @@
 import { ElasticBeanstalkClient } from "../ElasticBeanstalkClient";
 import { DescribeEnvironmentsCommand, DescribeEnvironmentsCommandInput } from "../commands/DescribeEnvironmentsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: ElasticBeanstalkClient,
   input: DescribeEnvironmentsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeEnvironmentsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Environments);
@@ -21,7 +23,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "Ready";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,16 +39,17 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "Updating";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeEnvironmentsCommand for polling.
+ *  @deprecated Use waitUntilEnvironmentUpdated instead. waitForEnvironmentUpdated does not throw error in non-success cases.
  */
 export const waitForEnvironmentUpdated = async (
   params: WaiterConfiguration<ElasticBeanstalkClient>,
@@ -55,3 +58,16 @@ export const waitForEnvironmentUpdated = async (
   const serviceDefaults = { minDelay: 20, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeEnvironmentsCommand for polling.
+ */
+export const waitUntilEnvironmentUpdated = async (
+  params: WaiterConfiguration<ElasticBeanstalkClient>,
+  input: DescribeEnvironmentsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-elastic-load-balancing/waiters/waitForAnyInstanceInService.ts b/clients/client-elastic-load-balancing/waiters/waitForAnyInstanceInService.ts
index 85344209f5a19..8ccbbf887c61d 100644
--- a/clients/client-elastic-load-balancing/waiters/waitForAnyInstanceInService.ts
+++ b/clients/client-elastic-load-balancing/waiters/waitForAnyInstanceInService.ts
@@ -3,14 +3,16 @@ import {
   DescribeInstanceHealthCommand,
   DescribeInstanceHealthCommandInput,
 } from "../commands/DescribeInstanceHealthCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: ElasticLoadBalancingClient,
   input: DescribeInstanceHealthCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeInstanceHealthCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.InstanceStates);
@@ -21,17 +23,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "InService") {
-          return { state: WaiterState.SUCCESS };
+          return { state: WaiterState.SUCCESS, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeInstanceHealthCommand for polling.
+ *  @deprecated Use waitUntilAnyInstanceInService instead. waitForAnyInstanceInService does not throw error in non-success cases.
  */
 export const waitForAnyInstanceInService = async (
   params: WaiterConfiguration<ElasticLoadBalancingClient>,
@@ -40,3 +43,16 @@ export const waitForAnyInstanceInService = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeInstanceHealthCommand for polling.
+ */
+export const waitUntilAnyInstanceInService = async (
+  params: WaiterConfiguration<ElasticLoadBalancingClient>,
+  input: DescribeInstanceHealthCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-elastic-transcoder/waiters/waitForJobComplete.ts b/clients/client-elastic-transcoder/waiters/waitForJobComplete.ts
index f715ebf06ca1f..978e5c3a433ab 100644
--- a/clients/client-elastic-transcoder/waiters/waitForJobComplete.ts
+++ b/clients/client-elastic-transcoder/waiters/waitForJobComplete.ts
@@ -1,16 +1,18 @@
 import { ElasticTranscoderClient } from "../ElasticTranscoderClient";
 import { ReadJobCommand, ReadJobCommandInput } from "../commands/ReadJobCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: ElasticTranscoderClient, input: ReadJobCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new ReadJobCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.Job.Status;
       };
       if (returnComparator() === "Complete") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,7 +20,7 @@ const checkState = async (client: ElasticTranscoderClient, input: ReadJobCommand
         return result.Job.Status;
       };
       if (returnComparator() === "Canceled") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -26,16 +28,17 @@ const checkState = async (client: ElasticTranscoderClient, input: ReadJobCommand
         return result.Job.Status;
       };
       if (returnComparator() === "Error") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to ReadJobCommand for polling.
+ *  @deprecated Use waitUntilJobComplete instead. waitForJobComplete does not throw error in non-success cases.
  */
 export const waitForJobComplete = async (
   params: WaiterConfiguration<ElasticTranscoderClient>,
@@ -44,3 +47,16 @@ export const waitForJobComplete = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to ReadJobCommand for polling.
+ */
+export const waitUntilJobComplete = async (
+  params: WaiterConfiguration<ElasticTranscoderClient>,
+  input: ReadJobCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-elasticache/waiters/waitForCacheClusterAvailable.ts b/clients/client-elasticache/waiters/waitForCacheClusterAvailable.ts
index c21a68823ae26..2fafdd889b957 100644
--- a/clients/client-elasticache/waiters/waitForCacheClusterAvailable.ts
+++ b/clients/client-elasticache/waiters/waitForCacheClusterAvailable.ts
@@ -3,14 +3,16 @@ import {
   DescribeCacheClustersCommand,
   DescribeCacheClustersCommandInput,
 } from "../commands/DescribeCacheClustersCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: ElastiCacheClient,
   input: DescribeCacheClustersCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeCacheClustersCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.CacheClusters);
@@ -24,7 +26,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,7 +39,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleted") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -51,7 +53,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -65,7 +67,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "incompatible-network") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -79,17 +81,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "restore-failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until ElastiCache cluster is available.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeCacheClustersCommand for polling.
+ *  @deprecated Use waitUntilCacheClusterAvailable instead. waitForCacheClusterAvailable does not throw error in non-success cases.
  */
 export const waitForCacheClusterAvailable = async (
   params: WaiterConfiguration<ElastiCacheClient>,
@@ -98,3 +101,16 @@ export const waitForCacheClusterAvailable = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until ElastiCache cluster is available.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeCacheClustersCommand for polling.
+ */
+export const waitUntilCacheClusterAvailable = async (
+  params: WaiterConfiguration<ElastiCacheClient>,
+  input: DescribeCacheClustersCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-elasticache/waiters/waitForReplicationGroupAvailable.ts b/clients/client-elasticache/waiters/waitForReplicationGroupAvailable.ts
index eb74b94056cb6..52a2f86fec555 100644
--- a/clients/client-elasticache/waiters/waitForReplicationGroupAvailable.ts
+++ b/clients/client-elasticache/waiters/waitForReplicationGroupAvailable.ts
@@ -3,14 +3,16 @@ import {
   DescribeReplicationGroupsCommand,
   DescribeReplicationGroupsCommandInput,
 } from "../commands/DescribeReplicationGroupsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: ElastiCacheClient,
   input: DescribeReplicationGroupsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeReplicationGroupsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ReplicationGroups);
@@ -24,7 +26,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,17 +39,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleted") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until ElastiCache replication group is available.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeReplicationGroupsCommand for polling.
+ *  @deprecated Use waitUntilReplicationGroupAvailable instead. waitForReplicationGroupAvailable does not throw error in non-success cases.
  */
 export const waitForReplicationGroupAvailable = async (
   params: WaiterConfiguration<ElastiCacheClient>,
@@ -56,3 +59,16 @@ export const waitForReplicationGroupAvailable = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until ElastiCache replication group is available.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeReplicationGroupsCommand for polling.
+ */
+export const waitUntilReplicationGroupAvailable = async (
+  params: WaiterConfiguration<ElastiCacheClient>,
+  input: DescribeReplicationGroupsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-elasticache/waiters/waitForReplicationGroupDeleted.ts b/clients/client-elasticache/waiters/waitForReplicationGroupDeleted.ts
index 5d3c48a169459..25e4ed07a1fc0 100644
--- a/clients/client-elasticache/waiters/waitForReplicationGroupDeleted.ts
+++ b/clients/client-elasticache/waiters/waitForReplicationGroupDeleted.ts
@@ -3,14 +3,16 @@ import {
   DescribeReplicationGroupsCommand,
   DescribeReplicationGroupsCommandInput,
 } from "../commands/DescribeReplicationGroupsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: ElastiCacheClient,
   input: DescribeReplicationGroupsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeReplicationGroupsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ReplicationGroups);
@@ -24,7 +26,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "deleted";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,21 +39,21 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "available") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ReplicationGroupNotFoundFault") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until ElastiCache replication group is deleted.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeReplicationGroupsCommand for polling.
+ *  @deprecated Use waitUntilReplicationGroupDeleted instead. waitForReplicationGroupDeleted does not throw error in non-success cases.
  */
 export const waitForReplicationGroupDeleted = async (
   params: WaiterConfiguration<ElastiCacheClient>,
@@ -60,3 +62,16 @@ export const waitForReplicationGroupDeleted = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until ElastiCache replication group is deleted.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeReplicationGroupsCommand for polling.
+ */
+export const waitUntilReplicationGroupDeleted = async (
+  params: WaiterConfiguration<ElastiCacheClient>,
+  input: DescribeReplicationGroupsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-emr/waiters/waitForClusterRunning.ts b/clients/client-emr/waiters/waitForClusterRunning.ts
index c6701b7d5ee6f..0d2427e4318c2 100644
--- a/clients/client-emr/waiters/waitForClusterRunning.ts
+++ b/clients/client-emr/waiters/waitForClusterRunning.ts
@@ -1,16 +1,18 @@
 import { EMRClient } from "../EMRClient";
 import { DescribeClusterCommand, DescribeClusterCommandInput } from "../commands/DescribeClusterCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EMRClient, input: DescribeClusterCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeClusterCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.Cluster.Status.State;
       };
       if (returnComparator() === "RUNNING") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,7 +20,7 @@ const checkState = async (client: EMRClient, input: DescribeClusterCommandInput)
         return result.Cluster.Status.State;
       };
       if (returnComparator() === "WAITING") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -26,7 +28,7 @@ const checkState = async (client: EMRClient, input: DescribeClusterCommandInput)
         return result.Cluster.Status.State;
       };
       if (returnComparator() === "TERMINATING") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -34,7 +36,7 @@ const checkState = async (client: EMRClient, input: DescribeClusterCommandInput)
         return result.Cluster.Status.State;
       };
       if (returnComparator() === "TERMINATED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -42,16 +44,17 @@ const checkState = async (client: EMRClient, input: DescribeClusterCommandInput)
         return result.Cluster.Status.State;
       };
       if (returnComparator() === "TERMINATED_WITH_ERRORS") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeClusterCommand for polling.
+ *  @deprecated Use waitUntilClusterRunning instead. waitForClusterRunning does not throw error in non-success cases.
  */
 export const waitForClusterRunning = async (
   params: WaiterConfiguration<EMRClient>,
@@ -60,3 +63,16 @@ export const waitForClusterRunning = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeClusterCommand for polling.
+ */
+export const waitUntilClusterRunning = async (
+  params: WaiterConfiguration<EMRClient>,
+  input: DescribeClusterCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-emr/waiters/waitForClusterTerminated.ts b/clients/client-emr/waiters/waitForClusterTerminated.ts
index 1c01c58a63920..348c9344098f0 100644
--- a/clients/client-emr/waiters/waitForClusterTerminated.ts
+++ b/clients/client-emr/waiters/waitForClusterTerminated.ts
@@ -1,16 +1,18 @@
 import { EMRClient } from "../EMRClient";
 import { DescribeClusterCommand, DescribeClusterCommandInput } from "../commands/DescribeClusterCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EMRClient, input: DescribeClusterCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeClusterCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.Cluster.Status.State;
       };
       if (returnComparator() === "TERMINATED") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,16 +20,17 @@ const checkState = async (client: EMRClient, input: DescribeClusterCommandInput)
         return result.Cluster.Status.State;
       };
       if (returnComparator() === "TERMINATED_WITH_ERRORS") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeClusterCommand for polling.
+ *  @deprecated Use waitUntilClusterTerminated instead. waitForClusterTerminated does not throw error in non-success cases.
  */
 export const waitForClusterTerminated = async (
   params: WaiterConfiguration<EMRClient>,
@@ -36,3 +39,16 @@ export const waitForClusterTerminated = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeClusterCommand for polling.
+ */
+export const waitUntilClusterTerminated = async (
+  params: WaiterConfiguration<EMRClient>,
+  input: DescribeClusterCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-emr/waiters/waitForStepComplete.ts b/clients/client-emr/waiters/waitForStepComplete.ts
index 98ba546af0582..30df5ffa4aaf5 100644
--- a/clients/client-emr/waiters/waitForStepComplete.ts
+++ b/clients/client-emr/waiters/waitForStepComplete.ts
@@ -1,16 +1,18 @@
 import { EMRClient } from "../EMRClient";
 import { DescribeStepCommand, DescribeStepCommandInput } from "../commands/DescribeStepCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: EMRClient, input: DescribeStepCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeStepCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.Step.Status.State;
       };
       if (returnComparator() === "COMPLETED") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,7 +20,7 @@ const checkState = async (client: EMRClient, input: DescribeStepCommandInput): P
         return result.Step.Status.State;
       };
       if (returnComparator() === "FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -26,16 +28,17 @@ const checkState = async (client: EMRClient, input: DescribeStepCommandInput): P
         return result.Step.Status.State;
       };
       if (returnComparator() === "CANCELLED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeStepCommand for polling.
+ *  @deprecated Use waitUntilStepComplete instead. waitForStepComplete does not throw error in non-success cases.
  */
 export const waitForStepComplete = async (
   params: WaiterConfiguration<EMRClient>,
@@ -44,3 +47,16 @@ export const waitForStepComplete = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeStepCommand for polling.
+ */
+export const waitUntilStepComplete = async (
+  params: WaiterConfiguration<EMRClient>,
+  input: DescribeStepCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-glacier/waiters/waitForVaultExists.ts b/clients/client-glacier/waiters/waitForVaultExists.ts
index 39af34cc48c62..3508838d6ec66 100644
--- a/clients/client-glacier/waiters/waitForVaultExists.ts
+++ b/clients/client-glacier/waiters/waitForVaultExists.ts
@@ -1,22 +1,24 @@
 import { GlacierClient } from "../GlacierClient";
 import { DescribeVaultCommand, DescribeVaultCommandInput } from "../commands/DescribeVaultCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: GlacierClient, input: DescribeVaultCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeVaultCommand(input));
-    return { state: WaiterState.SUCCESS };
+    reason = result;
+    return { state: WaiterState.SUCCESS, reason };
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeVaultCommand for polling.
+ *  @deprecated Use waitUntilVaultExists instead. waitForVaultExists does not throw error in non-success cases.
  */
 export const waitForVaultExists = async (
   params: WaiterConfiguration<GlacierClient>,
@@ -25,3 +27,16 @@ export const waitForVaultExists = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeVaultCommand for polling.
+ */
+export const waitUntilVaultExists = async (
+  params: WaiterConfiguration<GlacierClient>,
+  input: DescribeVaultCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-glacier/waiters/waitForVaultNotExists.ts b/clients/client-glacier/waiters/waitForVaultNotExists.ts
index 9cbcb77945f01..f09ffd916caff 100644
--- a/clients/client-glacier/waiters/waitForVaultNotExists.ts
+++ b/clients/client-glacier/waiters/waitForVaultNotExists.ts
@@ -1,22 +1,24 @@
 import { GlacierClient } from "../GlacierClient";
 import { DescribeVaultCommand, DescribeVaultCommandInput } from "../commands/DescribeVaultCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: GlacierClient, input: DescribeVaultCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeVaultCommand(input));
-    return { state: WaiterState.RETRY };
+    reason = result;
+    return { state: WaiterState.RETRY, reason };
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeVaultCommand for polling.
+ *  @deprecated Use waitUntilVaultNotExists instead. waitForVaultNotExists does not throw error in non-success cases.
  */
 export const waitForVaultNotExists = async (
   params: WaiterConfiguration<GlacierClient>,
@@ -25,3 +27,16 @@ export const waitForVaultNotExists = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeVaultCommand for polling.
+ */
+export const waitUntilVaultNotExists = async (
+  params: WaiterConfiguration<GlacierClient>,
+  input: DescribeVaultCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-iam/waiters/waitForInstanceProfileExists.ts b/clients/client-iam/waiters/waitForInstanceProfileExists.ts
index a111876423fd9..ac00fb62cd3f3 100644
--- a/clients/client-iam/waiters/waitForInstanceProfileExists.ts
+++ b/clients/client-iam/waiters/waitForInstanceProfileExists.ts
@@ -1,22 +1,24 @@
 import { IAMClient } from "../IAMClient";
 import { GetInstanceProfileCommand, GetInstanceProfileCommandInput } from "../commands/GetInstanceProfileCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: IAMClient, input: GetInstanceProfileCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetInstanceProfileCommand(input));
-    return { state: WaiterState.SUCCESS };
+    reason = result;
+    return { state: WaiterState.SUCCESS, reason };
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "NoSuchEntityException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetInstanceProfileCommand for polling.
+ *  @deprecated Use waitUntilInstanceProfileExists instead. waitForInstanceProfileExists does not throw error in non-success cases.
  */
 export const waitForInstanceProfileExists = async (
   params: WaiterConfiguration<IAMClient>,
@@ -25,3 +27,16 @@ export const waitForInstanceProfileExists = async (
   const serviceDefaults = { minDelay: 1, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetInstanceProfileCommand for polling.
+ */
+export const waitUntilInstanceProfileExists = async (
+  params: WaiterConfiguration<IAMClient>,
+  input: GetInstanceProfileCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-iotsitewise/waiters/waitForAssetActive.ts b/clients/client-iotsitewise/waiters/waitForAssetActive.ts
index b9f32dfbe86c9..e6710735e093e 100644
--- a/clients/client-iotsitewise/waiters/waitForAssetActive.ts
+++ b/clients/client-iotsitewise/waiters/waitForAssetActive.ts
@@ -1,16 +1,18 @@
 import { IoTSiteWiseClient } from "../IoTSiteWiseClient";
 import { DescribeAssetCommand, DescribeAssetCommandInput } from "../commands/DescribeAssetCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: IoTSiteWiseClient, input: DescribeAssetCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeAssetCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.assetStatus.state;
       };
       if (returnComparator() === "ACTIVE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,16 +20,17 @@ const checkState = async (client: IoTSiteWiseClient, input: DescribeAssetCommand
         return result.assetStatus.state;
       };
       if (returnComparator() === "FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeAssetCommand for polling.
+ *  @deprecated Use waitUntilAssetActive instead. waitForAssetActive does not throw error in non-success cases.
  */
 export const waitForAssetActive = async (
   params: WaiterConfiguration<IoTSiteWiseClient>,
@@ -36,3 +39,16 @@ export const waitForAssetActive = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeAssetCommand for polling.
+ */
+export const waitUntilAssetActive = async (
+  params: WaiterConfiguration<IoTSiteWiseClient>,
+  input: DescribeAssetCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-iotsitewise/waiters/waitForAssetModelActive.ts b/clients/client-iotsitewise/waiters/waitForAssetModelActive.ts
index 721b8bf17bf96..2b3fb87321e0c 100644
--- a/clients/client-iotsitewise/waiters/waitForAssetModelActive.ts
+++ b/clients/client-iotsitewise/waiters/waitForAssetModelActive.ts
@@ -1,16 +1,18 @@
 import { IoTSiteWiseClient } from "../IoTSiteWiseClient";
 import { DescribeAssetModelCommand, DescribeAssetModelCommandInput } from "../commands/DescribeAssetModelCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: IoTSiteWiseClient, input: DescribeAssetModelCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeAssetModelCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.assetModelStatus.state;
       };
       if (returnComparator() === "ACTIVE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,16 +20,17 @@ const checkState = async (client: IoTSiteWiseClient, input: DescribeAssetModelCo
         return result.assetModelStatus.state;
       };
       if (returnComparator() === "FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeAssetModelCommand for polling.
+ *  @deprecated Use waitUntilAssetModelActive instead. waitForAssetModelActive does not throw error in non-success cases.
  */
 export const waitForAssetModelActive = async (
   params: WaiterConfiguration<IoTSiteWiseClient>,
@@ -36,3 +39,16 @@ export const waitForAssetModelActive = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeAssetModelCommand for polling.
+ */
+export const waitUntilAssetModelActive = async (
+  params: WaiterConfiguration<IoTSiteWiseClient>,
+  input: DescribeAssetModelCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-iotsitewise/waiters/waitForAssetModelNotExists.ts b/clients/client-iotsitewise/waiters/waitForAssetModelNotExists.ts
index b1bb4e87de368..de37cdb31924a 100644
--- a/clients/client-iotsitewise/waiters/waitForAssetModelNotExists.ts
+++ b/clients/client-iotsitewise/waiters/waitForAssetModelNotExists.ts
@@ -1,21 +1,23 @@
 import { IoTSiteWiseClient } from "../IoTSiteWiseClient";
 import { DescribeAssetModelCommand, DescribeAssetModelCommandInput } from "../commands/DescribeAssetModelCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: IoTSiteWiseClient, input: DescribeAssetModelCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeAssetModelCommand(input));
+    reason = result;
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeAssetModelCommand for polling.
+ *  @deprecated Use waitUntilAssetModelNotExists instead. waitForAssetModelNotExists does not throw error in non-success cases.
  */
 export const waitForAssetModelNotExists = async (
   params: WaiterConfiguration<IoTSiteWiseClient>,
@@ -24,3 +26,16 @@ export const waitForAssetModelNotExists = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeAssetModelCommand for polling.
+ */
+export const waitUntilAssetModelNotExists = async (
+  params: WaiterConfiguration<IoTSiteWiseClient>,
+  input: DescribeAssetModelCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-iotsitewise/waiters/waitForAssetNotExists.ts b/clients/client-iotsitewise/waiters/waitForAssetNotExists.ts
index 72f8fbc839c1f..ab0b8b5b4c7dc 100644
--- a/clients/client-iotsitewise/waiters/waitForAssetNotExists.ts
+++ b/clients/client-iotsitewise/waiters/waitForAssetNotExists.ts
@@ -1,21 +1,23 @@
 import { IoTSiteWiseClient } from "../IoTSiteWiseClient";
 import { DescribeAssetCommand, DescribeAssetCommandInput } from "../commands/DescribeAssetCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: IoTSiteWiseClient, input: DescribeAssetCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeAssetCommand(input));
+    reason = result;
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeAssetCommand for polling.
+ *  @deprecated Use waitUntilAssetNotExists instead. waitForAssetNotExists does not throw error in non-success cases.
  */
 export const waitForAssetNotExists = async (
   params: WaiterConfiguration<IoTSiteWiseClient>,
@@ -24,3 +26,16 @@ export const waitForAssetNotExists = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeAssetCommand for polling.
+ */
+export const waitUntilAssetNotExists = async (
+  params: WaiterConfiguration<IoTSiteWiseClient>,
+  input: DescribeAssetCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-iotsitewise/waiters/waitForPortalActive.ts b/clients/client-iotsitewise/waiters/waitForPortalActive.ts
index 25230cbd7978a..7eb9ea482af14 100644
--- a/clients/client-iotsitewise/waiters/waitForPortalActive.ts
+++ b/clients/client-iotsitewise/waiters/waitForPortalActive.ts
@@ -1,25 +1,28 @@
 import { IoTSiteWiseClient } from "../IoTSiteWiseClient";
 import { DescribePortalCommand, DescribePortalCommandInput } from "../commands/DescribePortalCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: IoTSiteWiseClient, input: DescribePortalCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribePortalCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.portalStatus.state;
       };
       if (returnComparator() === "ACTIVE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribePortalCommand for polling.
+ *  @deprecated Use waitUntilPortalActive instead. waitForPortalActive does not throw error in non-success cases.
  */
 export const waitForPortalActive = async (
   params: WaiterConfiguration<IoTSiteWiseClient>,
@@ -28,3 +31,16 @@ export const waitForPortalActive = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribePortalCommand for polling.
+ */
+export const waitUntilPortalActive = async (
+  params: WaiterConfiguration<IoTSiteWiseClient>,
+  input: DescribePortalCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-iotsitewise/waiters/waitForPortalNotExists.ts b/clients/client-iotsitewise/waiters/waitForPortalNotExists.ts
index 61fa35076f8c7..6442f6d13d419 100644
--- a/clients/client-iotsitewise/waiters/waitForPortalNotExists.ts
+++ b/clients/client-iotsitewise/waiters/waitForPortalNotExists.ts
@@ -1,21 +1,23 @@
 import { IoTSiteWiseClient } from "../IoTSiteWiseClient";
 import { DescribePortalCommand, DescribePortalCommandInput } from "../commands/DescribePortalCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: IoTSiteWiseClient, input: DescribePortalCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribePortalCommand(input));
+    reason = result;
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribePortalCommand for polling.
+ *  @deprecated Use waitUntilPortalNotExists instead. waitForPortalNotExists does not throw error in non-success cases.
  */
 export const waitForPortalNotExists = async (
   params: WaiterConfiguration<IoTSiteWiseClient>,
@@ -24,3 +26,16 @@ export const waitForPortalNotExists = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribePortalCommand for polling.
+ */
+export const waitUntilPortalNotExists = async (
+  params: WaiterConfiguration<IoTSiteWiseClient>,
+  input: DescribePortalCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-kinesis/waiters/waitForStreamExists.ts b/clients/client-kinesis/waiters/waitForStreamExists.ts
index da4030d80a69d..e8079d3eba506 100644
--- a/clients/client-kinesis/waiters/waitForStreamExists.ts
+++ b/clients/client-kinesis/waiters/waitForStreamExists.ts
@@ -1,25 +1,28 @@
 import { KinesisClient } from "../KinesisClient";
 import { DescribeStreamCommand, DescribeStreamCommandInput } from "../commands/DescribeStreamCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: KinesisClient, input: DescribeStreamCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeStreamCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.StreamDescription.StreamStatus;
       };
       if (returnComparator() === "ACTIVE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeStreamCommand for polling.
+ *  @deprecated Use waitUntilStreamExists instead. waitForStreamExists does not throw error in non-success cases.
  */
 export const waitForStreamExists = async (
   params: WaiterConfiguration<KinesisClient>,
@@ -28,3 +31,16 @@ export const waitForStreamExists = async (
   const serviceDefaults = { minDelay: 10, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeStreamCommand for polling.
+ */
+export const waitUntilStreamExists = async (
+  params: WaiterConfiguration<KinesisClient>,
+  input: DescribeStreamCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-kinesis/waiters/waitForStreamNotExists.ts b/clients/client-kinesis/waiters/waitForStreamNotExists.ts
index 5dc13868fa1aa..27663ebb6acc5 100644
--- a/clients/client-kinesis/waiters/waitForStreamNotExists.ts
+++ b/clients/client-kinesis/waiters/waitForStreamNotExists.ts
@@ -1,21 +1,23 @@
 import { KinesisClient } from "../KinesisClient";
 import { DescribeStreamCommand, DescribeStreamCommandInput } from "../commands/DescribeStreamCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: KinesisClient, input: DescribeStreamCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeStreamCommand(input));
+    reason = result;
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeStreamCommand for polling.
+ *  @deprecated Use waitUntilStreamNotExists instead. waitForStreamNotExists does not throw error in non-success cases.
  */
 export const waitForStreamNotExists = async (
   params: WaiterConfiguration<KinesisClient>,
@@ -24,3 +26,16 @@ export const waitForStreamNotExists = async (
   const serviceDefaults = { minDelay: 10, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeStreamCommand for polling.
+ */
+export const waitUntilStreamNotExists = async (
+  params: WaiterConfiguration<KinesisClient>,
+  input: DescribeStreamCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-lambda/waiters/waitForFunctionActive.ts b/clients/client-lambda/waiters/waitForFunctionActive.ts
index c6ead81949f32..b1d98a76a68c4 100644
--- a/clients/client-lambda/waiters/waitForFunctionActive.ts
+++ b/clients/client-lambda/waiters/waitForFunctionActive.ts
@@ -3,17 +3,19 @@ import {
   GetFunctionConfigurationCommand,
   GetFunctionConfigurationCommandInput,
 } from "../commands/GetFunctionConfigurationCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: LambdaClient, input: GetFunctionConfigurationCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetFunctionConfigurationCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.State;
       };
       if (returnComparator() === "Active") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -21,7 +23,7 @@ const checkState = async (client: LambdaClient, input: GetFunctionConfigurationC
         return result.State;
       };
       if (returnComparator() === "Failed") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -29,16 +31,17 @@ const checkState = async (client: LambdaClient, input: GetFunctionConfigurationC
         return result.State;
       };
       if (returnComparator() === "Pending") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Waits for the function's State to be Active.
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetFunctionConfigurationCommand for polling.
+ *  @deprecated Use waitUntilFunctionActive instead. waitForFunctionActive does not throw error in non-success cases.
  */
 export const waitForFunctionActive = async (
   params: WaiterConfiguration<LambdaClient>,
@@ -47,3 +50,16 @@ export const waitForFunctionActive = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Waits for the function's State to be Active.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetFunctionConfigurationCommand for polling.
+ */
+export const waitUntilFunctionActive = async (
+  params: WaiterConfiguration<LambdaClient>,
+  input: GetFunctionConfigurationCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-lambda/waiters/waitForFunctionExists.ts b/clients/client-lambda/waiters/waitForFunctionExists.ts
index 2afe6a046bd7c..9c7e30abec7e9 100644
--- a/clients/client-lambda/waiters/waitForFunctionExists.ts
+++ b/clients/client-lambda/waiters/waitForFunctionExists.ts
@@ -1,22 +1,24 @@
 import { LambdaClient } from "../LambdaClient";
 import { GetFunctionCommand, GetFunctionCommandInput } from "../commands/GetFunctionCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: LambdaClient, input: GetFunctionCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetFunctionCommand(input));
-    return { state: WaiterState.SUCCESS };
+    reason = result;
+    return { state: WaiterState.SUCCESS, reason };
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetFunctionCommand for polling.
+ *  @deprecated Use waitUntilFunctionExists instead. waitForFunctionExists does not throw error in non-success cases.
  */
 export const waitForFunctionExists = async (
   params: WaiterConfiguration<LambdaClient>,
@@ -25,3 +27,16 @@ export const waitForFunctionExists = async (
   const serviceDefaults = { minDelay: 1, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetFunctionCommand for polling.
+ */
+export const waitUntilFunctionExists = async (
+  params: WaiterConfiguration<LambdaClient>,
+  input: GetFunctionCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-lambda/waiters/waitForFunctionUpdated.ts b/clients/client-lambda/waiters/waitForFunctionUpdated.ts
index 64b1065474d79..32bf3065a790c 100644
--- a/clients/client-lambda/waiters/waitForFunctionUpdated.ts
+++ b/clients/client-lambda/waiters/waitForFunctionUpdated.ts
@@ -3,17 +3,19 @@ import {
   GetFunctionConfigurationCommand,
   GetFunctionConfigurationCommandInput,
 } from "../commands/GetFunctionConfigurationCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: LambdaClient, input: GetFunctionConfigurationCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetFunctionConfigurationCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.LastUpdateStatus;
       };
       if (returnComparator() === "Successful") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -21,7 +23,7 @@ const checkState = async (client: LambdaClient, input: GetFunctionConfigurationC
         return result.LastUpdateStatus;
       };
       if (returnComparator() === "Failed") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -29,16 +31,17 @@ const checkState = async (client: LambdaClient, input: GetFunctionConfigurationC
         return result.LastUpdateStatus;
       };
       if (returnComparator() === "InProgress") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Waits for the function's LastUpdateStatus to be Successful.
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetFunctionConfigurationCommand for polling.
+ *  @deprecated Use waitUntilFunctionUpdated instead. waitForFunctionUpdated does not throw error in non-success cases.
  */
 export const waitForFunctionUpdated = async (
   params: WaiterConfiguration<LambdaClient>,
@@ -47,3 +50,16 @@ export const waitForFunctionUpdated = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Waits for the function's LastUpdateStatus to be Successful.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetFunctionConfigurationCommand for polling.
+ */
+export const waitUntilFunctionUpdated = async (
+  params: WaiterConfiguration<LambdaClient>,
+  input: GetFunctionConfigurationCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-machine-learning/waiters/waitForBatchPredictionAvailable.ts b/clients/client-machine-learning/waiters/waitForBatchPredictionAvailable.ts
index ef4108d91b632..68b2d52edd503 100644
--- a/clients/client-machine-learning/waiters/waitForBatchPredictionAvailable.ts
+++ b/clients/client-machine-learning/waiters/waitForBatchPredictionAvailable.ts
@@ -3,14 +3,16 @@ import {
   DescribeBatchPredictionsCommand,
   DescribeBatchPredictionsCommandInput,
 } from "../commands/DescribeBatchPredictionsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: MachineLearningClient,
   input: DescribeBatchPredictionsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeBatchPredictionsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Results);
@@ -24,7 +26,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "COMPLETED";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,17 +39,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "FAILED") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeBatchPredictionsCommand for polling.
+ *  @deprecated Use waitUntilBatchPredictionAvailable instead. waitForBatchPredictionAvailable does not throw error in non-success cases.
  */
 export const waitForBatchPredictionAvailable = async (
   params: WaiterConfiguration<MachineLearningClient>,
@@ -56,3 +59,16 @@ export const waitForBatchPredictionAvailable = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeBatchPredictionsCommand for polling.
+ */
+export const waitUntilBatchPredictionAvailable = async (
+  params: WaiterConfiguration<MachineLearningClient>,
+  input: DescribeBatchPredictionsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-machine-learning/waiters/waitForDataSourceAvailable.ts b/clients/client-machine-learning/waiters/waitForDataSourceAvailable.ts
index 6954d617d64a0..76c1a17e23e52 100644
--- a/clients/client-machine-learning/waiters/waitForDataSourceAvailable.ts
+++ b/clients/client-machine-learning/waiters/waitForDataSourceAvailable.ts
@@ -1,13 +1,15 @@
 import { MachineLearningClient } from "../MachineLearningClient";
 import { DescribeDataSourcesCommand, DescribeDataSourcesCommandInput } from "../commands/DescribeDataSourcesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: MachineLearningClient,
   input: DescribeDataSourcesCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeDataSourcesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Results);
@@ -21,7 +23,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "COMPLETED";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -34,17 +36,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "FAILED") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeDataSourcesCommand for polling.
+ *  @deprecated Use waitUntilDataSourceAvailable instead. waitForDataSourceAvailable does not throw error in non-success cases.
  */
 export const waitForDataSourceAvailable = async (
   params: WaiterConfiguration<MachineLearningClient>,
@@ -53,3 +56,16 @@ export const waitForDataSourceAvailable = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeDataSourcesCommand for polling.
+ */
+export const waitUntilDataSourceAvailable = async (
+  params: WaiterConfiguration<MachineLearningClient>,
+  input: DescribeDataSourcesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-machine-learning/waiters/waitForEvaluationAvailable.ts b/clients/client-machine-learning/waiters/waitForEvaluationAvailable.ts
index 909bdaf98f9c5..86c11bf8c3449 100644
--- a/clients/client-machine-learning/waiters/waitForEvaluationAvailable.ts
+++ b/clients/client-machine-learning/waiters/waitForEvaluationAvailable.ts
@@ -1,13 +1,15 @@
 import { MachineLearningClient } from "../MachineLearningClient";
 import { DescribeEvaluationsCommand, DescribeEvaluationsCommandInput } from "../commands/DescribeEvaluationsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: MachineLearningClient,
   input: DescribeEvaluationsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeEvaluationsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Results);
@@ -21,7 +23,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "COMPLETED";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -34,17 +36,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "FAILED") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeEvaluationsCommand for polling.
+ *  @deprecated Use waitUntilEvaluationAvailable instead. waitForEvaluationAvailable does not throw error in non-success cases.
  */
 export const waitForEvaluationAvailable = async (
   params: WaiterConfiguration<MachineLearningClient>,
@@ -53,3 +56,16 @@ export const waitForEvaluationAvailable = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeEvaluationsCommand for polling.
+ */
+export const waitUntilEvaluationAvailable = async (
+  params: WaiterConfiguration<MachineLearningClient>,
+  input: DescribeEvaluationsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-machine-learning/waiters/waitForMLModelAvailable.ts b/clients/client-machine-learning/waiters/waitForMLModelAvailable.ts
index d25386584f274..d22ac678d1d91 100644
--- a/clients/client-machine-learning/waiters/waitForMLModelAvailable.ts
+++ b/clients/client-machine-learning/waiters/waitForMLModelAvailable.ts
@@ -1,13 +1,15 @@
 import { MachineLearningClient } from "../MachineLearningClient";
 import { DescribeMLModelsCommand, DescribeMLModelsCommandInput } from "../commands/DescribeMLModelsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: MachineLearningClient,
   input: DescribeMLModelsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeMLModelsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Results);
@@ -21,7 +23,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "COMPLETED";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -34,17 +36,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "FAILED") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeMLModelsCommand for polling.
+ *  @deprecated Use waitUntilMLModelAvailable instead. waitForMLModelAvailable does not throw error in non-success cases.
  */
 export const waitForMLModelAvailable = async (
   params: WaiterConfiguration<MachineLearningClient>,
@@ -53,3 +56,16 @@ export const waitForMLModelAvailable = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeMLModelsCommand for polling.
+ */
+export const waitUntilMLModelAvailable = async (
+  params: WaiterConfiguration<MachineLearningClient>,
+  input: DescribeMLModelsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-mediaconnect/waiters/waitForFlowActive.ts b/clients/client-mediaconnect/waiters/waitForFlowActive.ts
index 6be8336506b43..c2975e68b5ef6 100644
--- a/clients/client-mediaconnect/waiters/waitForFlowActive.ts
+++ b/clients/client-mediaconnect/waiters/waitForFlowActive.ts
@@ -1,16 +1,18 @@
 import { MediaConnectClient } from "../MediaConnectClient";
 import { DescribeFlowCommand, DescribeFlowCommandInput } from "../commands/DescribeFlowCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaConnectClient, input: DescribeFlowCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeFlowCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.Flow.Status;
       };
       if (returnComparator() === "ACTIVE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,7 +20,7 @@ const checkState = async (client: MediaConnectClient, input: DescribeFlowCommand
         return result.Flow.Status;
       };
       if (returnComparator() === "STARTING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
     try {
@@ -26,7 +28,7 @@ const checkState = async (client: MediaConnectClient, input: DescribeFlowCommand
         return result.Flow.Status;
       };
       if (returnComparator() === "UPDATING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
     try {
@@ -34,23 +36,23 @@ const checkState = async (client: MediaConnectClient, input: DescribeFlowCommand
         return result.Flow.Status;
       };
       if (returnComparator() === "ERROR") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
     if (exception.name && exception.name == "ServiceUnavailableException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a flow is active
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeFlowCommand for polling.
+ *  @deprecated Use waitUntilFlowActive instead. waitForFlowActive does not throw error in non-success cases.
  */
 export const waitForFlowActive = async (
   params: WaiterConfiguration<MediaConnectClient>,
@@ -59,3 +61,16 @@ export const waitForFlowActive = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a flow is active
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeFlowCommand for polling.
+ */
+export const waitUntilFlowActive = async (
+  params: WaiterConfiguration<MediaConnectClient>,
+  input: DescribeFlowCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-mediaconnect/waiters/waitForFlowDeleted.ts b/clients/client-mediaconnect/waiters/waitForFlowDeleted.ts
index 8c7b5551a1bca..189220336274b 100644
--- a/clients/client-mediaconnect/waiters/waitForFlowDeleted.ts
+++ b/clients/client-mediaconnect/waiters/waitForFlowDeleted.ts
@@ -1,16 +1,18 @@
 import { MediaConnectClient } from "../MediaConnectClient";
 import { DescribeFlowCommand, DescribeFlowCommandInput } from "../commands/DescribeFlowCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaConnectClient, input: DescribeFlowCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeFlowCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.Flow.Status;
       };
       if (returnComparator() === "DELETING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
     try {
@@ -18,26 +20,26 @@ const checkState = async (client: MediaConnectClient, input: DescribeFlowCommand
         return result.Flow.Status;
       };
       if (returnComparator() === "ERROR") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "NotFoundException") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
     if (exception.name && exception.name == "ServiceUnavailableException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a flow is deleted
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeFlowCommand for polling.
+ *  @deprecated Use waitUntilFlowDeleted instead. waitForFlowDeleted does not throw error in non-success cases.
  */
 export const waitForFlowDeleted = async (
   params: WaiterConfiguration<MediaConnectClient>,
@@ -46,3 +48,16 @@ export const waitForFlowDeleted = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a flow is deleted
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeFlowCommand for polling.
+ */
+export const waitUntilFlowDeleted = async (
+  params: WaiterConfiguration<MediaConnectClient>,
+  input: DescribeFlowCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-mediaconnect/waiters/waitForFlowStandby.ts b/clients/client-mediaconnect/waiters/waitForFlowStandby.ts
index 81ef3b70ad4f6..356412ce60bc0 100644
--- a/clients/client-mediaconnect/waiters/waitForFlowStandby.ts
+++ b/clients/client-mediaconnect/waiters/waitForFlowStandby.ts
@@ -1,16 +1,18 @@
 import { MediaConnectClient } from "../MediaConnectClient";
 import { DescribeFlowCommand, DescribeFlowCommandInput } from "../commands/DescribeFlowCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaConnectClient, input: DescribeFlowCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeFlowCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.Flow.Status;
       };
       if (returnComparator() === "STANDBY") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,7 +20,7 @@ const checkState = async (client: MediaConnectClient, input: DescribeFlowCommand
         return result.Flow.Status;
       };
       if (returnComparator() === "STOPPING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
     try {
@@ -26,23 +28,23 @@ const checkState = async (client: MediaConnectClient, input: DescribeFlowCommand
         return result.Flow.Status;
       };
       if (returnComparator() === "ERROR") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
     if (exception.name && exception.name == "ServiceUnavailableException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a flow is in standby mode
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeFlowCommand for polling.
+ *  @deprecated Use waitUntilFlowStandby instead. waitForFlowStandby does not throw error in non-success cases.
  */
 export const waitForFlowStandby = async (
   params: WaiterConfiguration<MediaConnectClient>,
@@ -51,3 +53,16 @@ export const waitForFlowStandby = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a flow is in standby mode
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeFlowCommand for polling.
+ */
+export const waitUntilFlowStandby = async (
+  params: WaiterConfiguration<MediaConnectClient>,
+  input: DescribeFlowCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-medialive/waiters/waitForChannelCreated.ts b/clients/client-medialive/waiters/waitForChannelCreated.ts
index e1aa3b377ee7a..3fa5de837c6e4 100644
--- a/clients/client-medialive/waiters/waitForChannelCreated.ts
+++ b/clients/client-medialive/waiters/waitForChannelCreated.ts
@@ -1,16 +1,18 @@
 import { MediaLiveClient } from "../MediaLiveClient";
 import { DescribeChannelCommand, DescribeChannelCommandInput } from "../commands/DescribeChannelCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaLiveClient, input: DescribeChannelCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeChannelCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.State;
       };
       if (returnComparator() === "IDLE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,7 +20,7 @@ const checkState = async (client: MediaLiveClient, input: DescribeChannelCommand
         return result.State;
       };
       if (returnComparator() === "CREATING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
     try {
@@ -26,20 +28,20 @@ const checkState = async (client: MediaLiveClient, input: DescribeChannelCommand
         return result.State;
       };
       if (returnComparator() === "CREATE_FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a channel has been created
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeChannelCommand for polling.
+ *  @deprecated Use waitUntilChannelCreated instead. waitForChannelCreated does not throw error in non-success cases.
  */
 export const waitForChannelCreated = async (
   params: WaiterConfiguration<MediaLiveClient>,
@@ -48,3 +50,16 @@ export const waitForChannelCreated = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a channel has been created
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeChannelCommand for polling.
+ */
+export const waitUntilChannelCreated = async (
+  params: WaiterConfiguration<MediaLiveClient>,
+  input: DescribeChannelCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-medialive/waiters/waitForChannelDeleted.ts b/clients/client-medialive/waiters/waitForChannelDeleted.ts
index e430846dd0a77..d4c4dd5e6c3c9 100644
--- a/clients/client-medialive/waiters/waitForChannelDeleted.ts
+++ b/clients/client-medialive/waiters/waitForChannelDeleted.ts
@@ -1,16 +1,18 @@
 import { MediaLiveClient } from "../MediaLiveClient";
 import { DescribeChannelCommand, DescribeChannelCommandInput } from "../commands/DescribeChannelCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaLiveClient, input: DescribeChannelCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeChannelCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.State;
       };
       if (returnComparator() === "DELETED") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,20 +20,20 @@ const checkState = async (client: MediaLiveClient, input: DescribeChannelCommand
         return result.State;
       };
       if (returnComparator() === "DELETING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a channel has been deleted
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeChannelCommand for polling.
+ *  @deprecated Use waitUntilChannelDeleted instead. waitForChannelDeleted does not throw error in non-success cases.
  */
 export const waitForChannelDeleted = async (
   params: WaiterConfiguration<MediaLiveClient>,
@@ -40,3 +42,16 @@ export const waitForChannelDeleted = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a channel has been deleted
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeChannelCommand for polling.
+ */
+export const waitUntilChannelDeleted = async (
+  params: WaiterConfiguration<MediaLiveClient>,
+  input: DescribeChannelCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-medialive/waiters/waitForChannelRunning.ts b/clients/client-medialive/waiters/waitForChannelRunning.ts
index 4993fd0a56f79..e46963e411cdb 100644
--- a/clients/client-medialive/waiters/waitForChannelRunning.ts
+++ b/clients/client-medialive/waiters/waitForChannelRunning.ts
@@ -1,16 +1,18 @@
 import { MediaLiveClient } from "../MediaLiveClient";
 import { DescribeChannelCommand, DescribeChannelCommandInput } from "../commands/DescribeChannelCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaLiveClient, input: DescribeChannelCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeChannelCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.State;
       };
       if (returnComparator() === "RUNNING") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,20 +20,20 @@ const checkState = async (client: MediaLiveClient, input: DescribeChannelCommand
         return result.State;
       };
       if (returnComparator() === "STARTING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a channel is running
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeChannelCommand for polling.
+ *  @deprecated Use waitUntilChannelRunning instead. waitForChannelRunning does not throw error in non-success cases.
  */
 export const waitForChannelRunning = async (
   params: WaiterConfiguration<MediaLiveClient>,
@@ -40,3 +42,16 @@ export const waitForChannelRunning = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a channel is running
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeChannelCommand for polling.
+ */
+export const waitUntilChannelRunning = async (
+  params: WaiterConfiguration<MediaLiveClient>,
+  input: DescribeChannelCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-medialive/waiters/waitForChannelStopped.ts b/clients/client-medialive/waiters/waitForChannelStopped.ts
index 5c01b9ab59971..32203626d592f 100644
--- a/clients/client-medialive/waiters/waitForChannelStopped.ts
+++ b/clients/client-medialive/waiters/waitForChannelStopped.ts
@@ -1,16 +1,18 @@
 import { MediaLiveClient } from "../MediaLiveClient";
 import { DescribeChannelCommand, DescribeChannelCommandInput } from "../commands/DescribeChannelCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaLiveClient, input: DescribeChannelCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeChannelCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.State;
       };
       if (returnComparator() === "IDLE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,20 +20,20 @@ const checkState = async (client: MediaLiveClient, input: DescribeChannelCommand
         return result.State;
       };
       if (returnComparator() === "STOPPING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a channel has is stopped
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeChannelCommand for polling.
+ *  @deprecated Use waitUntilChannelStopped instead. waitForChannelStopped does not throw error in non-success cases.
  */
 export const waitForChannelStopped = async (
   params: WaiterConfiguration<MediaLiveClient>,
@@ -40,3 +42,16 @@ export const waitForChannelStopped = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a channel has is stopped
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeChannelCommand for polling.
+ */
+export const waitUntilChannelStopped = async (
+  params: WaiterConfiguration<MediaLiveClient>,
+  input: DescribeChannelCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-medialive/waiters/waitForInputAttached.ts b/clients/client-medialive/waiters/waitForInputAttached.ts
index c6698d102b940..5693e1c9f9ac6 100644
--- a/clients/client-medialive/waiters/waitForInputAttached.ts
+++ b/clients/client-medialive/waiters/waitForInputAttached.ts
@@ -1,16 +1,18 @@
 import { MediaLiveClient } from "../MediaLiveClient";
 import { DescribeInputCommand, DescribeInputCommandInput } from "../commands/DescribeInputCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaLiveClient, input: DescribeInputCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeInputCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.State;
       };
       if (returnComparator() === "ATTACHED") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,20 +20,20 @@ const checkState = async (client: MediaLiveClient, input: DescribeInputCommandIn
         return result.State;
       };
       if (returnComparator() === "DETACHED") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until an input has been attached
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeInputCommand for polling.
+ *  @deprecated Use waitUntilInputAttached instead. waitForInputAttached does not throw error in non-success cases.
  */
 export const waitForInputAttached = async (
   params: WaiterConfiguration<MediaLiveClient>,
@@ -40,3 +42,16 @@ export const waitForInputAttached = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until an input has been attached
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeInputCommand for polling.
+ */
+export const waitUntilInputAttached = async (
+  params: WaiterConfiguration<MediaLiveClient>,
+  input: DescribeInputCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-medialive/waiters/waitForInputDeleted.ts b/clients/client-medialive/waiters/waitForInputDeleted.ts
index 0487cf1d13add..d5e8d1a8c8412 100644
--- a/clients/client-medialive/waiters/waitForInputDeleted.ts
+++ b/clients/client-medialive/waiters/waitForInputDeleted.ts
@@ -1,16 +1,18 @@
 import { MediaLiveClient } from "../MediaLiveClient";
 import { DescribeInputCommand, DescribeInputCommandInput } from "../commands/DescribeInputCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaLiveClient, input: DescribeInputCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeInputCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.State;
       };
       if (returnComparator() === "DELETED") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,20 +20,20 @@ const checkState = async (client: MediaLiveClient, input: DescribeInputCommandIn
         return result.State;
       };
       if (returnComparator() === "DELETING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until an input has been deleted
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeInputCommand for polling.
+ *  @deprecated Use waitUntilInputDeleted instead. waitForInputDeleted does not throw error in non-success cases.
  */
 export const waitForInputDeleted = async (
   params: WaiterConfiguration<MediaLiveClient>,
@@ -40,3 +42,16 @@ export const waitForInputDeleted = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until an input has been deleted
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeInputCommand for polling.
+ */
+export const waitUntilInputDeleted = async (
+  params: WaiterConfiguration<MediaLiveClient>,
+  input: DescribeInputCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-medialive/waiters/waitForInputDetached.ts b/clients/client-medialive/waiters/waitForInputDetached.ts
index c4b52c17ed99c..049d19ea3363e 100644
--- a/clients/client-medialive/waiters/waitForInputDetached.ts
+++ b/clients/client-medialive/waiters/waitForInputDetached.ts
@@ -1,16 +1,18 @@
 import { MediaLiveClient } from "../MediaLiveClient";
 import { DescribeInputCommand, DescribeInputCommandInput } from "../commands/DescribeInputCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaLiveClient, input: DescribeInputCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeInputCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.State;
       };
       if (returnComparator() === "DETACHED") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,7 +20,7 @@ const checkState = async (client: MediaLiveClient, input: DescribeInputCommandIn
         return result.State;
       };
       if (returnComparator() === "CREATING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
     try {
@@ -26,20 +28,20 @@ const checkState = async (client: MediaLiveClient, input: DescribeInputCommandIn
         return result.State;
       };
       if (returnComparator() === "ATTACHED") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until an input has been detached
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeInputCommand for polling.
+ *  @deprecated Use waitUntilInputDetached instead. waitForInputDetached does not throw error in non-success cases.
  */
 export const waitForInputDetached = async (
   params: WaiterConfiguration<MediaLiveClient>,
@@ -48,3 +50,16 @@ export const waitForInputDetached = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until an input has been detached
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeInputCommand for polling.
+ */
+export const waitUntilInputDetached = async (
+  params: WaiterConfiguration<MediaLiveClient>,
+  input: DescribeInputCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-medialive/waiters/waitForMultiplexCreated.ts b/clients/client-medialive/waiters/waitForMultiplexCreated.ts
index 0b240de1eaca1..b1ed4109d4f3b 100644
--- a/clients/client-medialive/waiters/waitForMultiplexCreated.ts
+++ b/clients/client-medialive/waiters/waitForMultiplexCreated.ts
@@ -1,16 +1,18 @@
 import { MediaLiveClient } from "../MediaLiveClient";
 import { DescribeMultiplexCommand, DescribeMultiplexCommandInput } from "../commands/DescribeMultiplexCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaLiveClient, input: DescribeMultiplexCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeMultiplexCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.State;
       };
       if (returnComparator() === "IDLE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,7 +20,7 @@ const checkState = async (client: MediaLiveClient, input: DescribeMultiplexComma
         return result.State;
       };
       if (returnComparator() === "CREATING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
     try {
@@ -26,20 +28,20 @@ const checkState = async (client: MediaLiveClient, input: DescribeMultiplexComma
         return result.State;
       };
       if (returnComparator() === "CREATE_FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a multiplex has been created
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeMultiplexCommand for polling.
+ *  @deprecated Use waitUntilMultiplexCreated instead. waitForMultiplexCreated does not throw error in non-success cases.
  */
 export const waitForMultiplexCreated = async (
   params: WaiterConfiguration<MediaLiveClient>,
@@ -48,3 +50,16 @@ export const waitForMultiplexCreated = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a multiplex has been created
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeMultiplexCommand for polling.
+ */
+export const waitUntilMultiplexCreated = async (
+  params: WaiterConfiguration<MediaLiveClient>,
+  input: DescribeMultiplexCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-medialive/waiters/waitForMultiplexDeleted.ts b/clients/client-medialive/waiters/waitForMultiplexDeleted.ts
index 9bcb1278af8d6..34351842aaa3b 100644
--- a/clients/client-medialive/waiters/waitForMultiplexDeleted.ts
+++ b/clients/client-medialive/waiters/waitForMultiplexDeleted.ts
@@ -1,16 +1,18 @@
 import { MediaLiveClient } from "../MediaLiveClient";
 import { DescribeMultiplexCommand, DescribeMultiplexCommandInput } from "../commands/DescribeMultiplexCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaLiveClient, input: DescribeMultiplexCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeMultiplexCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.State;
       };
       if (returnComparator() === "DELETED") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,20 +20,20 @@ const checkState = async (client: MediaLiveClient, input: DescribeMultiplexComma
         return result.State;
       };
       if (returnComparator() === "DELETING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a multiplex has been deleted
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeMultiplexCommand for polling.
+ *  @deprecated Use waitUntilMultiplexDeleted instead. waitForMultiplexDeleted does not throw error in non-success cases.
  */
 export const waitForMultiplexDeleted = async (
   params: WaiterConfiguration<MediaLiveClient>,
@@ -40,3 +42,16 @@ export const waitForMultiplexDeleted = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a multiplex has been deleted
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeMultiplexCommand for polling.
+ */
+export const waitUntilMultiplexDeleted = async (
+  params: WaiterConfiguration<MediaLiveClient>,
+  input: DescribeMultiplexCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-medialive/waiters/waitForMultiplexRunning.ts b/clients/client-medialive/waiters/waitForMultiplexRunning.ts
index ece5e94d635cc..c030583351b3b 100644
--- a/clients/client-medialive/waiters/waitForMultiplexRunning.ts
+++ b/clients/client-medialive/waiters/waitForMultiplexRunning.ts
@@ -1,16 +1,18 @@
 import { MediaLiveClient } from "../MediaLiveClient";
 import { DescribeMultiplexCommand, DescribeMultiplexCommandInput } from "../commands/DescribeMultiplexCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaLiveClient, input: DescribeMultiplexCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeMultiplexCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.State;
       };
       if (returnComparator() === "RUNNING") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,20 +20,20 @@ const checkState = async (client: MediaLiveClient, input: DescribeMultiplexComma
         return result.State;
       };
       if (returnComparator() === "STARTING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a multiplex is running
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeMultiplexCommand for polling.
+ *  @deprecated Use waitUntilMultiplexRunning instead. waitForMultiplexRunning does not throw error in non-success cases.
  */
 export const waitForMultiplexRunning = async (
   params: WaiterConfiguration<MediaLiveClient>,
@@ -40,3 +42,16 @@ export const waitForMultiplexRunning = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a multiplex is running
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeMultiplexCommand for polling.
+ */
+export const waitUntilMultiplexRunning = async (
+  params: WaiterConfiguration<MediaLiveClient>,
+  input: DescribeMultiplexCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-medialive/waiters/waitForMultiplexStopped.ts b/clients/client-medialive/waiters/waitForMultiplexStopped.ts
index b9c355ed949e0..1c9df0459e877 100644
--- a/clients/client-medialive/waiters/waitForMultiplexStopped.ts
+++ b/clients/client-medialive/waiters/waitForMultiplexStopped.ts
@@ -1,16 +1,18 @@
 import { MediaLiveClient } from "../MediaLiveClient";
 import { DescribeMultiplexCommand, DescribeMultiplexCommandInput } from "../commands/DescribeMultiplexCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: MediaLiveClient, input: DescribeMultiplexCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeMultiplexCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.State;
       };
       if (returnComparator() === "IDLE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,20 +20,20 @@ const checkState = async (client: MediaLiveClient, input: DescribeMultiplexComma
         return result.State;
       };
       if (returnComparator() === "STOPPING") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "InternalServerErrorException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a multiplex has is stopped
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeMultiplexCommand for polling.
+ *  @deprecated Use waitUntilMultiplexStopped instead. waitForMultiplexStopped does not throw error in non-success cases.
  */
 export const waitForMultiplexStopped = async (
   params: WaiterConfiguration<MediaLiveClient>,
@@ -40,3 +42,16 @@ export const waitForMultiplexStopped = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a multiplex has is stopped
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeMultiplexCommand for polling.
+ */
+export const waitUntilMultiplexStopped = async (
+  params: WaiterConfiguration<MediaLiveClient>,
+  input: DescribeMultiplexCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-neptune/waiters/waitForDBInstanceAvailable.ts b/clients/client-neptune/waiters/waitForDBInstanceAvailable.ts
index f85e30bbc6f8a..0991869307abc 100644
--- a/clients/client-neptune/waiters/waitForDBInstanceAvailable.ts
+++ b/clients/client-neptune/waiters/waitForDBInstanceAvailable.ts
@@ -1,10 +1,12 @@
 import { NeptuneClient } from "../NeptuneClient";
 import { DescribeDBInstancesCommand, DescribeDBInstancesCommandInput } from "../commands/DescribeDBInstancesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: NeptuneClient, input: DescribeDBInstancesCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeDBInstancesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.DBInstances);
@@ -18,7 +20,7 @@ const checkState = async (client: NeptuneClient, input: DescribeDBInstancesComma
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: NeptuneClient, input: DescribeDBInstancesComma
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleted") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -45,7 +47,7 @@ const checkState = async (client: NeptuneClient, input: DescribeDBInstancesComma
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -59,7 +61,7 @@ const checkState = async (client: NeptuneClient, input: DescribeDBInstancesComma
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -73,7 +75,7 @@ const checkState = async (client: NeptuneClient, input: DescribeDBInstancesComma
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "incompatible-restore") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -87,17 +89,18 @@ const checkState = async (client: NeptuneClient, input: DescribeDBInstancesComma
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "incompatible-parameters") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeDBInstancesCommand for polling.
+ *  @deprecated Use waitUntilDBInstanceAvailable instead. waitForDBInstanceAvailable does not throw error in non-success cases.
  */
 export const waitForDBInstanceAvailable = async (
   params: WaiterConfiguration<NeptuneClient>,
@@ -106,3 +109,16 @@ export const waitForDBInstanceAvailable = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeDBInstancesCommand for polling.
+ */
+export const waitUntilDBInstanceAvailable = async (
+  params: WaiterConfiguration<NeptuneClient>,
+  input: DescribeDBInstancesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-opsworks/waiters/waitForAppExists.ts b/clients/client-opsworks/waiters/waitForAppExists.ts
index c79659fb55f92..d39d186375e63 100644
--- a/clients/client-opsworks/waiters/waitForAppExists.ts
+++ b/clients/client-opsworks/waiters/waitForAppExists.ts
@@ -1,20 +1,22 @@
 import { OpsWorksClient } from "../OpsWorksClient";
 import { DescribeAppsCommand, DescribeAppsCommandInput } from "../commands/DescribeAppsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: OpsWorksClient, input: DescribeAppsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeAppsCommand(input));
-    return { state: WaiterState.SUCCESS };
+    reason = result;
+    return { state: WaiterState.SUCCESS, reason };
   } catch (exception) {
-    return { state: WaiterState.FAILURE };
+    reason = exception;
+    return { state: WaiterState.FAILURE, reason };
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeAppsCommand for polling.
+ *  @deprecated Use waitUntilAppExists instead. waitForAppExists does not throw error in non-success cases.
  */
 export const waitForAppExists = async (
   params: WaiterConfiguration<OpsWorksClient>,
@@ -23,3 +25,16 @@ export const waitForAppExists = async (
   const serviceDefaults = { minDelay: 1, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeAppsCommand for polling.
+ */
+export const waitUntilAppExists = async (
+  params: WaiterConfiguration<OpsWorksClient>,
+  input: DescribeAppsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-opsworks/waiters/waitForDeploymentSuccessful.ts b/clients/client-opsworks/waiters/waitForDeploymentSuccessful.ts
index 00dea0878fb82..3bf4513fac33e 100644
--- a/clients/client-opsworks/waiters/waitForDeploymentSuccessful.ts
+++ b/clients/client-opsworks/waiters/waitForDeploymentSuccessful.ts
@@ -1,10 +1,12 @@
 import { OpsWorksClient } from "../OpsWorksClient";
 import { DescribeDeploymentsCommand, DescribeDeploymentsCommandInput } from "../commands/DescribeDeploymentsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: OpsWorksClient, input: DescribeDeploymentsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeDeploymentsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Deployments);
@@ -18,7 +20,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeDeploymentsComm
         allStringEq_5 = allStringEq_5 && element_4 == "successful";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,17 +33,18 @@ const checkState = async (client: OpsWorksClient, input: DescribeDeploymentsComm
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a deployment has completed successfully.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeDeploymentsCommand for polling.
+ *  @deprecated Use waitUntilDeploymentSuccessful instead. waitForDeploymentSuccessful does not throw error in non-success cases.
  */
 export const waitForDeploymentSuccessful = async (
   params: WaiterConfiguration<OpsWorksClient>,
@@ -50,3 +53,16 @@ export const waitForDeploymentSuccessful = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a deployment has completed successfully.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeDeploymentsCommand for polling.
+ */
+export const waitUntilDeploymentSuccessful = async (
+  params: WaiterConfiguration<OpsWorksClient>,
+  input: DescribeDeploymentsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-opsworks/waiters/waitForInstanceOnline.ts b/clients/client-opsworks/waiters/waitForInstanceOnline.ts
index d60ec01c2fefe..c138ce1a6b325 100644
--- a/clients/client-opsworks/waiters/waitForInstanceOnline.ts
+++ b/clients/client-opsworks/waiters/waitForInstanceOnline.ts
@@ -1,10 +1,12 @@
 import { OpsWorksClient } from "../OpsWorksClient";
 import { DescribeInstancesCommand, DescribeInstancesCommandInput } from "../commands/DescribeInstancesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: OpsWorksClient, input: DescribeInstancesCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeInstancesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Instances);
@@ -18,7 +20,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
         allStringEq_5 = allStringEq_5 && element_4 == "online";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "setup_failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -45,7 +47,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "shutting_down") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -59,7 +61,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "start_failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -73,7 +75,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "stopped") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -87,7 +89,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "stopping") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -101,7 +103,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "terminating") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -115,7 +117,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "terminated") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -129,17 +131,18 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "stop_failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until OpsWorks instance is online.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeInstancesCommand for polling.
+ *  @deprecated Use waitUntilInstanceOnline instead. waitForInstanceOnline does not throw error in non-success cases.
  */
 export const waitForInstanceOnline = async (
   params: WaiterConfiguration<OpsWorksClient>,
@@ -148,3 +151,16 @@ export const waitForInstanceOnline = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until OpsWorks instance is online.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeInstancesCommand for polling.
+ */
+export const waitUntilInstanceOnline = async (
+  params: WaiterConfiguration<OpsWorksClient>,
+  input: DescribeInstancesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-opsworks/waiters/waitForInstanceRegistered.ts b/clients/client-opsworks/waiters/waitForInstanceRegistered.ts
index 96cf7a5c35b11..00841ca667f62 100644
--- a/clients/client-opsworks/waiters/waitForInstanceRegistered.ts
+++ b/clients/client-opsworks/waiters/waitForInstanceRegistered.ts
@@ -1,10 +1,12 @@
 import { OpsWorksClient } from "../OpsWorksClient";
 import { DescribeInstancesCommand, DescribeInstancesCommandInput } from "../commands/DescribeInstancesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: OpsWorksClient, input: DescribeInstancesCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeInstancesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Instances);
@@ -18,7 +20,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
         allStringEq_5 = allStringEq_5 && element_4 == "registered";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "setup_failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -45,7 +47,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "shutting_down") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -59,7 +61,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "stopped") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -73,7 +75,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "stopping") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -87,7 +89,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "terminating") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -101,7 +103,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "terminated") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -115,17 +117,18 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "stop_failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until OpsWorks instance is registered.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeInstancesCommand for polling.
+ *  @deprecated Use waitUntilInstanceRegistered instead. waitForInstanceRegistered does not throw error in non-success cases.
  */
 export const waitForInstanceRegistered = async (
   params: WaiterConfiguration<OpsWorksClient>,
@@ -134,3 +137,16 @@ export const waitForInstanceRegistered = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until OpsWorks instance is registered.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeInstancesCommand for polling.
+ */
+export const waitUntilInstanceRegistered = async (
+  params: WaiterConfiguration<OpsWorksClient>,
+  input: DescribeInstancesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-opsworks/waiters/waitForInstanceStopped.ts b/clients/client-opsworks/waiters/waitForInstanceStopped.ts
index be5e35d1a07ed..bbb8a8c9d1b86 100644
--- a/clients/client-opsworks/waiters/waitForInstanceStopped.ts
+++ b/clients/client-opsworks/waiters/waitForInstanceStopped.ts
@@ -1,10 +1,12 @@
 import { OpsWorksClient } from "../OpsWorksClient";
 import { DescribeInstancesCommand, DescribeInstancesCommandInput } from "../commands/DescribeInstancesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: OpsWorksClient, input: DescribeInstancesCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeInstancesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Instances);
@@ -18,7 +20,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
         allStringEq_5 = allStringEq_5 && element_4 == "stopped";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "booting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -45,7 +47,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "pending") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -59,7 +61,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "rebooting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -73,7 +75,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "requested") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -87,7 +89,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "running_setup") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -101,7 +103,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "setup_failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -115,7 +117,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "start_failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -129,17 +131,18 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "stop_failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until OpsWorks instance is stopped.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeInstancesCommand for polling.
+ *  @deprecated Use waitUntilInstanceStopped instead. waitForInstanceStopped does not throw error in non-success cases.
  */
 export const waitForInstanceStopped = async (
   params: WaiterConfiguration<OpsWorksClient>,
@@ -148,3 +151,16 @@ export const waitForInstanceStopped = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until OpsWorks instance is stopped.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeInstancesCommand for polling.
+ */
+export const waitUntilInstanceStopped = async (
+  params: WaiterConfiguration<OpsWorksClient>,
+  input: DescribeInstancesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-opsworks/waiters/waitForInstanceTerminated.ts b/clients/client-opsworks/waiters/waitForInstanceTerminated.ts
index 5b5f4a2a3ea50..c0d8306cb2f5f 100644
--- a/clients/client-opsworks/waiters/waitForInstanceTerminated.ts
+++ b/clients/client-opsworks/waiters/waitForInstanceTerminated.ts
@@ -1,10 +1,12 @@
 import { OpsWorksClient } from "../OpsWorksClient";
 import { DescribeInstancesCommand, DescribeInstancesCommandInput } from "../commands/DescribeInstancesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: OpsWorksClient, input: DescribeInstancesCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeInstancesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Instances);
@@ -18,7 +20,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
         allStringEq_5 = allStringEq_5 && element_4 == "terminated";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "booting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -45,7 +47,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "online") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -59,7 +61,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "pending") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -73,7 +75,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "rebooting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -87,7 +89,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "requested") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -101,7 +103,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "running_setup") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -115,7 +117,7 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "setup_failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -129,21 +131,21 @@ const checkState = async (client: OpsWorksClient, input: DescribeInstancesComman
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "start_failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until OpsWorks instance is terminated.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeInstancesCommand for polling.
+ *  @deprecated Use waitUntilInstanceTerminated instead. waitForInstanceTerminated does not throw error in non-success cases.
  */
 export const waitForInstanceTerminated = async (
   params: WaiterConfiguration<OpsWorksClient>,
@@ -152,3 +154,16 @@ export const waitForInstanceTerminated = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until OpsWorks instance is terminated.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeInstancesCommand for polling.
+ */
+export const waitUntilInstanceTerminated = async (
+  params: WaiterConfiguration<OpsWorksClient>,
+  input: DescribeInstancesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-opsworkscm/waiters/waitForNodeAssociated.ts b/clients/client-opsworkscm/waiters/waitForNodeAssociated.ts
index c612b1ca26ee2..2426f5439c114 100644
--- a/clients/client-opsworkscm/waiters/waitForNodeAssociated.ts
+++ b/clients/client-opsworkscm/waiters/waitForNodeAssociated.ts
@@ -3,20 +3,22 @@ import {
   DescribeNodeAssociationStatusCommand,
   DescribeNodeAssociationStatusCommandInput,
 } from "../commands/DescribeNodeAssociationStatusCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: OpsWorksCMClient,
   input: DescribeNodeAssociationStatusCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeNodeAssociationStatusCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.NodeAssociationStatus;
       };
       if (returnComparator() === "SUCCESS") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -24,16 +26,17 @@ const checkState = async (
         return result.NodeAssociationStatus;
       };
       if (returnComparator() === "FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until node is associated or disassociated.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeNodeAssociationStatusCommand for polling.
+ *  @deprecated Use waitUntilNodeAssociated instead. waitForNodeAssociated does not throw error in non-success cases.
  */
 export const waitForNodeAssociated = async (
   params: WaiterConfiguration<OpsWorksCMClient>,
@@ -42,3 +45,16 @@ export const waitForNodeAssociated = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until node is associated or disassociated.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeNodeAssociationStatusCommand for polling.
+ */
+export const waitUntilNodeAssociated = async (
+  params: WaiterConfiguration<OpsWorksCMClient>,
+  input: DescribeNodeAssociationStatusCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-rds/waiters/waitForDBClusterSnapshotAvailable.ts b/clients/client-rds/waiters/waitForDBClusterSnapshotAvailable.ts
index 610ea8882d2e3..73022c5f3f5fe 100644
--- a/clients/client-rds/waiters/waitForDBClusterSnapshotAvailable.ts
+++ b/clients/client-rds/waiters/waitForDBClusterSnapshotAvailable.ts
@@ -3,11 +3,13 @@ import {
   DescribeDBClusterSnapshotsCommand,
   DescribeDBClusterSnapshotsCommandInput,
 } from "../commands/DescribeDBClusterSnapshotsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: RDSClient, input: DescribeDBClusterSnapshotsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeDBClusterSnapshotsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.DBClusterSnapshots);
@@ -21,7 +23,7 @@ const checkState = async (client: RDSClient, input: DescribeDBClusterSnapshotsCo
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -34,7 +36,7 @@ const checkState = async (client: RDSClient, input: DescribeDBClusterSnapshotsCo
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleted") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -48,7 +50,7 @@ const checkState = async (client: RDSClient, input: DescribeDBClusterSnapshotsCo
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -62,7 +64,7 @@ const checkState = async (client: RDSClient, input: DescribeDBClusterSnapshotsCo
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -76,7 +78,7 @@ const checkState = async (client: RDSClient, input: DescribeDBClusterSnapshotsCo
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "incompatible-restore") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -90,17 +92,18 @@ const checkState = async (client: RDSClient, input: DescribeDBClusterSnapshotsCo
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "incompatible-parameters") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeDBClusterSnapshotsCommand for polling.
+ *  @deprecated Use waitUntilDBClusterSnapshotAvailable instead. waitForDBClusterSnapshotAvailable does not throw error in non-success cases.
  */
 export const waitForDBClusterSnapshotAvailable = async (
   params: WaiterConfiguration<RDSClient>,
@@ -109,3 +112,16 @@ export const waitForDBClusterSnapshotAvailable = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeDBClusterSnapshotsCommand for polling.
+ */
+export const waitUntilDBClusterSnapshotAvailable = async (
+  params: WaiterConfiguration<RDSClient>,
+  input: DescribeDBClusterSnapshotsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-rds/waiters/waitForDBClusterSnapshotDeleted.ts b/clients/client-rds/waiters/waitForDBClusterSnapshotDeleted.ts
index cf8a29ea24fdf..840524045c35d 100644
--- a/clients/client-rds/waiters/waitForDBClusterSnapshotDeleted.ts
+++ b/clients/client-rds/waiters/waitForDBClusterSnapshotDeleted.ts
@@ -3,17 +3,19 @@ import {
   DescribeDBClusterSnapshotsCommand,
   DescribeDBClusterSnapshotsCommandInput,
 } from "../commands/DescribeDBClusterSnapshotsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: RDSClient, input: DescribeDBClusterSnapshotsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeDBClusterSnapshotsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.DBClusterSnapshots.length == 0.0;
       };
       if (returnComparator() == true) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -26,7 +28,7 @@ const checkState = async (client: RDSClient, input: DescribeDBClusterSnapshotsCo
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "creating") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -40,7 +42,7 @@ const checkState = async (client: RDSClient, input: DescribeDBClusterSnapshotsCo
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "modifying") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -54,7 +56,7 @@ const checkState = async (client: RDSClient, input: DescribeDBClusterSnapshotsCo
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "rebooting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -68,21 +70,21 @@ const checkState = async (client: RDSClient, input: DescribeDBClusterSnapshotsCo
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "resetting-master-credentials") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "DBClusterSnapshotNotFoundFault") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeDBClusterSnapshotsCommand for polling.
+ *  @deprecated Use waitUntilDBClusterSnapshotDeleted instead. waitForDBClusterSnapshotDeleted does not throw error in non-success cases.
  */
 export const waitForDBClusterSnapshotDeleted = async (
   params: WaiterConfiguration<RDSClient>,
@@ -91,3 +93,16 @@ export const waitForDBClusterSnapshotDeleted = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeDBClusterSnapshotsCommand for polling.
+ */
+export const waitUntilDBClusterSnapshotDeleted = async (
+  params: WaiterConfiguration<RDSClient>,
+  input: DescribeDBClusterSnapshotsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-rds/waiters/waitForDBInstanceAvailable.ts b/clients/client-rds/waiters/waitForDBInstanceAvailable.ts
index 4a96aac3b7df0..bae64230ebb75 100644
--- a/clients/client-rds/waiters/waitForDBInstanceAvailable.ts
+++ b/clients/client-rds/waiters/waitForDBInstanceAvailable.ts
@@ -1,10 +1,12 @@
 import { RDSClient } from "../RDSClient";
 import { DescribeDBInstancesCommand, DescribeDBInstancesCommandInput } from "../commands/DescribeDBInstancesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: RDSClient, input: DescribeDBInstancesCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeDBInstancesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.DBInstances);
@@ -18,7 +20,7 @@ const checkState = async (client: RDSClient, input: DescribeDBInstancesCommandIn
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: RDSClient, input: DescribeDBInstancesCommandIn
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleted") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -45,7 +47,7 @@ const checkState = async (client: RDSClient, input: DescribeDBInstancesCommandIn
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -59,7 +61,7 @@ const checkState = async (client: RDSClient, input: DescribeDBInstancesCommandIn
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -73,7 +75,7 @@ const checkState = async (client: RDSClient, input: DescribeDBInstancesCommandIn
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "incompatible-restore") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -87,17 +89,18 @@ const checkState = async (client: RDSClient, input: DescribeDBInstancesCommandIn
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "incompatible-parameters") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeDBInstancesCommand for polling.
+ *  @deprecated Use waitUntilDBInstanceAvailable instead. waitForDBInstanceAvailable does not throw error in non-success cases.
  */
 export const waitForDBInstanceAvailable = async (
   params: WaiterConfiguration<RDSClient>,
@@ -106,3 +109,16 @@ export const waitForDBInstanceAvailable = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeDBInstancesCommand for polling.
+ */
+export const waitUntilDBInstanceAvailable = async (
+  params: WaiterConfiguration<RDSClient>,
+  input: DescribeDBInstancesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-rds/waiters/waitForDBSnapshotAvailable.ts b/clients/client-rds/waiters/waitForDBSnapshotAvailable.ts
index 323224b6fab1b..74d37a2c21b21 100644
--- a/clients/client-rds/waiters/waitForDBSnapshotAvailable.ts
+++ b/clients/client-rds/waiters/waitForDBSnapshotAvailable.ts
@@ -1,10 +1,12 @@
 import { RDSClient } from "../RDSClient";
 import { DescribeDBSnapshotsCommand, DescribeDBSnapshotsCommandInput } from "../commands/DescribeDBSnapshotsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: RDSClient, input: DescribeDBSnapshotsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeDBSnapshotsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.DBSnapshots);
@@ -18,7 +20,7 @@ const checkState = async (client: RDSClient, input: DescribeDBSnapshotsCommandIn
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: RDSClient, input: DescribeDBSnapshotsCommandIn
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleted") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -45,7 +47,7 @@ const checkState = async (client: RDSClient, input: DescribeDBSnapshotsCommandIn
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -59,7 +61,7 @@ const checkState = async (client: RDSClient, input: DescribeDBSnapshotsCommandIn
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -73,7 +75,7 @@ const checkState = async (client: RDSClient, input: DescribeDBSnapshotsCommandIn
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "incompatible-restore") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -87,17 +89,18 @@ const checkState = async (client: RDSClient, input: DescribeDBSnapshotsCommandIn
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "incompatible-parameters") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeDBSnapshotsCommand for polling.
+ *  @deprecated Use waitUntilDBSnapshotAvailable instead. waitForDBSnapshotAvailable does not throw error in non-success cases.
  */
 export const waitForDBSnapshotAvailable = async (
   params: WaiterConfiguration<RDSClient>,
@@ -106,3 +109,16 @@ export const waitForDBSnapshotAvailable = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeDBSnapshotsCommand for polling.
+ */
+export const waitUntilDBSnapshotAvailable = async (
+  params: WaiterConfiguration<RDSClient>,
+  input: DescribeDBSnapshotsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-redshift/waiters/waitForClusterRestored.ts b/clients/client-redshift/waiters/waitForClusterRestored.ts
index 33319f9700e28..ea2f955359494 100644
--- a/clients/client-redshift/waiters/waitForClusterRestored.ts
+++ b/clients/client-redshift/waiters/waitForClusterRestored.ts
@@ -1,10 +1,12 @@
 import { RedshiftClient } from "../RedshiftClient";
 import { DescribeClustersCommand, DescribeClustersCommandInput } from "../commands/DescribeClustersCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: RedshiftClient, input: DescribeClustersCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeClustersCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Clusters);
@@ -18,7 +20,7 @@ const checkState = async (client: RedshiftClient, input: DescribeClustersCommand
         allStringEq_5 = allStringEq_5 && element_4 == "completed";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,17 +33,18 @@ const checkState = async (client: RedshiftClient, input: DescribeClustersCommand
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleting") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeClustersCommand for polling.
+ *  @deprecated Use waitUntilClusterRestored instead. waitForClusterRestored does not throw error in non-success cases.
  */
 export const waitForClusterRestored = async (
   params: WaiterConfiguration<RedshiftClient>,
@@ -50,3 +53,16 @@ export const waitForClusterRestored = async (
   const serviceDefaults = { minDelay: 60, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeClustersCommand for polling.
+ */
+export const waitUntilClusterRestored = async (
+  params: WaiterConfiguration<RedshiftClient>,
+  input: DescribeClustersCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-redshift/waiters/waitForSnapshotAvailable.ts b/clients/client-redshift/waiters/waitForSnapshotAvailable.ts
index d1fb67026f05d..e5c383eb36872 100644
--- a/clients/client-redshift/waiters/waitForSnapshotAvailable.ts
+++ b/clients/client-redshift/waiters/waitForSnapshotAvailable.ts
@@ -3,14 +3,16 @@ import {
   DescribeClusterSnapshotsCommand,
   DescribeClusterSnapshotsCommandInput,
 } from "../commands/DescribeClusterSnapshotsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: RedshiftClient,
   input: DescribeClusterSnapshotsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeClusterSnapshotsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Snapshots);
@@ -24,7 +26,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,7 +39,7 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "failed") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -51,17 +53,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "deleted") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeClusterSnapshotsCommand for polling.
+ *  @deprecated Use waitUntilSnapshotAvailable instead. waitForSnapshotAvailable does not throw error in non-success cases.
  */
 export const waitForSnapshotAvailable = async (
   params: WaiterConfiguration<RedshiftClient>,
@@ -70,3 +73,16 @@ export const waitForSnapshotAvailable = async (
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeClusterSnapshotsCommand for polling.
+ */
+export const waitUntilSnapshotAvailable = async (
+  params: WaiterConfiguration<RedshiftClient>,
+  input: DescribeClusterSnapshotsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-rekognition/waiters/waitForProjectVersionRunning.ts b/clients/client-rekognition/waiters/waitForProjectVersionRunning.ts
index f883487cd0557..6db0fd2ed8257 100644
--- a/clients/client-rekognition/waiters/waitForProjectVersionRunning.ts
+++ b/clients/client-rekognition/waiters/waitForProjectVersionRunning.ts
@@ -3,14 +3,16 @@ import {
   DescribeProjectVersionsCommand,
   DescribeProjectVersionsCommandInput,
 } from "../commands/DescribeProjectVersionsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: RekognitionClient,
   input: DescribeProjectVersionsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeProjectVersionsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ProjectVersionDescriptions);
@@ -24,7 +26,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "RUNNING";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,17 +39,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "FAILED") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until the ProjectVersion is running.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeProjectVersionsCommand for polling.
+ *  @deprecated Use waitUntilProjectVersionRunning instead. waitForProjectVersionRunning does not throw error in non-success cases.
  */
 export const waitForProjectVersionRunning = async (
   params: WaiterConfiguration<RekognitionClient>,
@@ -56,3 +59,16 @@ export const waitForProjectVersionRunning = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until the ProjectVersion is running.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeProjectVersionsCommand for polling.
+ */
+export const waitUntilProjectVersionRunning = async (
+  params: WaiterConfiguration<RekognitionClient>,
+  input: DescribeProjectVersionsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-rekognition/waiters/waitForProjectVersionTrainingCompleted.ts b/clients/client-rekognition/waiters/waitForProjectVersionTrainingCompleted.ts
index 3ab9e372d9e57..94b0baeffa843 100644
--- a/clients/client-rekognition/waiters/waitForProjectVersionTrainingCompleted.ts
+++ b/clients/client-rekognition/waiters/waitForProjectVersionTrainingCompleted.ts
@@ -3,14 +3,16 @@ import {
   DescribeProjectVersionsCommand,
   DescribeProjectVersionsCommandInput,
 } from "../commands/DescribeProjectVersionsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: RekognitionClient,
   input: DescribeProjectVersionsCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeProjectVersionsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.ProjectVersionDescriptions);
@@ -24,7 +26,7 @@ const checkState = async (
         allStringEq_5 = allStringEq_5 && element_4 == "TRAINING_COMPLETED";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -37,17 +39,18 @@ const checkState = async (
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "TRAINING_FAILED") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until the ProjectVersion training completes.
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeProjectVersionsCommand for polling.
+ *  @deprecated Use waitUntilProjectVersionTrainingCompleted instead. waitForProjectVersionTrainingCompleted does not throw error in non-success cases.
  */
 export const waitForProjectVersionTrainingCompleted = async (
   params: WaiterConfiguration<RekognitionClient>,
@@ -56,3 +59,16 @@ export const waitForProjectVersionTrainingCompleted = async (
   const serviceDefaults = { minDelay: 120, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until the ProjectVersion training completes.
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeProjectVersionsCommand for polling.
+ */
+export const waitUntilProjectVersionTrainingCompleted = async (
+  params: WaiterConfiguration<RekognitionClient>,
+  input: DescribeProjectVersionsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-route-53/waiters/waitForResourceRecordSetsChanged.ts b/clients/client-route-53/waiters/waitForResourceRecordSetsChanged.ts
index f4b26ebf72e25..00dd5efaa61d0 100644
--- a/clients/client-route-53/waiters/waitForResourceRecordSetsChanged.ts
+++ b/clients/client-route-53/waiters/waitForResourceRecordSetsChanged.ts
@@ -1,25 +1,28 @@
 import { Route53Client } from "../Route53Client";
 import { GetChangeCommand, GetChangeCommandInput } from "../commands/GetChangeCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: Route53Client, input: GetChangeCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetChangeCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.ChangeInfo.Status;
       };
       if (returnComparator() === "INSYNC") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetChangeCommand for polling.
+ *  @deprecated Use waitUntilResourceRecordSetsChanged instead. waitForResourceRecordSetsChanged does not throw error in non-success cases.
  */
 export const waitForResourceRecordSetsChanged = async (
   params: WaiterConfiguration<Route53Client>,
@@ -28,3 +31,16 @@ export const waitForResourceRecordSetsChanged = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetChangeCommand for polling.
+ */
+export const waitUntilResourceRecordSetsChanged = async (
+  params: WaiterConfiguration<Route53Client>,
+  input: GetChangeCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-s3/waiters/waitForBucketExists.ts b/clients/client-s3/waiters/waitForBucketExists.ts
index b2014675e5d1e..2fc0c10162382 100644
--- a/clients/client-s3/waiters/waitForBucketExists.ts
+++ b/clients/client-s3/waiters/waitForBucketExists.ts
@@ -1,22 +1,24 @@
 import { S3Client } from "../S3Client";
 import { HeadBucketCommand, HeadBucketCommandInput } from "../commands/HeadBucketCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: S3Client, input: HeadBucketCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new HeadBucketCommand(input));
-    return { state: WaiterState.SUCCESS };
+    reason = result;
+    return { state: WaiterState.SUCCESS, reason };
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "NotFound") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to HeadBucketCommand for polling.
+ *  @deprecated Use waitUntilBucketExists instead. waitForBucketExists does not throw error in non-success cases.
  */
 export const waitForBucketExists = async (
   params: WaiterConfiguration<S3Client>,
@@ -25,3 +27,16 @@ export const waitForBucketExists = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to HeadBucketCommand for polling.
+ */
+export const waitUntilBucketExists = async (
+  params: WaiterConfiguration<S3Client>,
+  input: HeadBucketCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-s3/waiters/waitForBucketNotExists.ts b/clients/client-s3/waiters/waitForBucketNotExists.ts
index ac6b10a3bf2d2..b40b6d68f7b25 100644
--- a/clients/client-s3/waiters/waitForBucketNotExists.ts
+++ b/clients/client-s3/waiters/waitForBucketNotExists.ts
@@ -1,21 +1,23 @@
 import { S3Client } from "../S3Client";
 import { HeadBucketCommand, HeadBucketCommandInput } from "../commands/HeadBucketCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: S3Client, input: HeadBucketCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new HeadBucketCommand(input));
+    reason = result;
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "NotFound") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to HeadBucketCommand for polling.
+ *  @deprecated Use waitUntilBucketNotExists instead. waitForBucketNotExists does not throw error in non-success cases.
  */
 export const waitForBucketNotExists = async (
   params: WaiterConfiguration<S3Client>,
@@ -24,3 +26,16 @@ export const waitForBucketNotExists = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to HeadBucketCommand for polling.
+ */
+export const waitUntilBucketNotExists = async (
+  params: WaiterConfiguration<S3Client>,
+  input: HeadBucketCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-s3/waiters/waitForObjectExists.ts b/clients/client-s3/waiters/waitForObjectExists.ts
index d42c31060ecc6..c5ce9fe95afa5 100644
--- a/clients/client-s3/waiters/waitForObjectExists.ts
+++ b/clients/client-s3/waiters/waitForObjectExists.ts
@@ -1,22 +1,24 @@
 import { S3Client } from "../S3Client";
 import { HeadObjectCommand, HeadObjectCommandInput } from "../commands/HeadObjectCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: S3Client, input: HeadObjectCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new HeadObjectCommand(input));
-    return { state: WaiterState.SUCCESS };
+    reason = result;
+    return { state: WaiterState.SUCCESS, reason };
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "NotFound") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to HeadObjectCommand for polling.
+ *  @deprecated Use waitUntilObjectExists instead. waitForObjectExists does not throw error in non-success cases.
  */
 export const waitForObjectExists = async (
   params: WaiterConfiguration<S3Client>,
@@ -25,3 +27,16 @@ export const waitForObjectExists = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to HeadObjectCommand for polling.
+ */
+export const waitUntilObjectExists = async (
+  params: WaiterConfiguration<S3Client>,
+  input: HeadObjectCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-s3/waiters/waitForObjectNotExists.ts b/clients/client-s3/waiters/waitForObjectNotExists.ts
index 137f7d2cb0b88..b70496ec053cf 100644
--- a/clients/client-s3/waiters/waitForObjectNotExists.ts
+++ b/clients/client-s3/waiters/waitForObjectNotExists.ts
@@ -1,21 +1,23 @@
 import { S3Client } from "../S3Client";
 import { HeadObjectCommand, HeadObjectCommandInput } from "../commands/HeadObjectCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: S3Client, input: HeadObjectCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new HeadObjectCommand(input));
+    reason = result;
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "NotFound") {
-      return { state: WaiterState.SUCCESS };
+      return { state: WaiterState.SUCCESS, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to HeadObjectCommand for polling.
+ *  @deprecated Use waitUntilObjectNotExists instead. waitForObjectNotExists does not throw error in non-success cases.
  */
 export const waitForObjectNotExists = async (
   params: WaiterConfiguration<S3Client>,
@@ -24,3 +26,16 @@ export const waitForObjectNotExists = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to HeadObjectCommand for polling.
+ */
+export const waitUntilObjectNotExists = async (
+  params: WaiterConfiguration<S3Client>,
+  input: HeadObjectCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-sagemaker/waiters/waitForNotebookInstanceInService.ts b/clients/client-sagemaker/waiters/waitForNotebookInstanceInService.ts
index 59d045af3fc8d..9dd150fdbf755 100644
--- a/clients/client-sagemaker/waiters/waitForNotebookInstanceInService.ts
+++ b/clients/client-sagemaker/waiters/waitForNotebookInstanceInService.ts
@@ -3,20 +3,22 @@ import {
   DescribeNotebookInstanceCommand,
   DescribeNotebookInstanceCommandInput,
 } from "../commands/DescribeNotebookInstanceCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: SageMakerClient,
   input: DescribeNotebookInstanceCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeNotebookInstanceCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.NotebookInstanceStatus;
       };
       if (returnComparator() === "InService") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -24,16 +26,17 @@ const checkState = async (
         return result.NotebookInstanceStatus;
       };
       if (returnComparator() === "Failed") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeNotebookInstanceCommand for polling.
+ *  @deprecated Use waitUntilNotebookInstanceInService instead. waitForNotebookInstanceInService does not throw error in non-success cases.
  */
 export const waitForNotebookInstanceInService = async (
   params: WaiterConfiguration<SageMakerClient>,
@@ -42,3 +45,16 @@ export const waitForNotebookInstanceInService = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeNotebookInstanceCommand for polling.
+ */
+export const waitUntilNotebookInstanceInService = async (
+  params: WaiterConfiguration<SageMakerClient>,
+  input: DescribeNotebookInstanceCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-sagemaker/waiters/waitForNotebookInstanceStopped.ts b/clients/client-sagemaker/waiters/waitForNotebookInstanceStopped.ts
index 5f7e3e59430de..c0f739bd75238 100644
--- a/clients/client-sagemaker/waiters/waitForNotebookInstanceStopped.ts
+++ b/clients/client-sagemaker/waiters/waitForNotebookInstanceStopped.ts
@@ -3,20 +3,22 @@ import {
   DescribeNotebookInstanceCommand,
   DescribeNotebookInstanceCommandInput,
 } from "../commands/DescribeNotebookInstanceCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: SageMakerClient,
   input: DescribeNotebookInstanceCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeNotebookInstanceCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.NotebookInstanceStatus;
       };
       if (returnComparator() === "Stopped") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -24,16 +26,17 @@ const checkState = async (
         return result.NotebookInstanceStatus;
       };
       if (returnComparator() === "Failed") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeNotebookInstanceCommand for polling.
+ *  @deprecated Use waitUntilNotebookInstanceStopped instead. waitForNotebookInstanceStopped does not throw error in non-success cases.
  */
 export const waitForNotebookInstanceStopped = async (
   params: WaiterConfiguration<SageMakerClient>,
@@ -42,3 +45,16 @@ export const waitForNotebookInstanceStopped = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeNotebookInstanceCommand for polling.
+ */
+export const waitUntilNotebookInstanceStopped = async (
+  params: WaiterConfiguration<SageMakerClient>,
+  input: DescribeNotebookInstanceCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-schemas/waiters/waitForCodeBindingExists.ts b/clients/client-schemas/waiters/waitForCodeBindingExists.ts
index 8d23177e3538e..0424c69bac228 100644
--- a/clients/client-schemas/waiters/waitForCodeBindingExists.ts
+++ b/clients/client-schemas/waiters/waitForCodeBindingExists.ts
@@ -1,16 +1,18 @@
 import { SchemasClient } from "../SchemasClient";
 import { DescribeCodeBindingCommand, DescribeCodeBindingCommandInput } from "../commands/DescribeCodeBindingCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: SchemasClient, input: DescribeCodeBindingCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeCodeBindingCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.Status;
       };
       if (returnComparator() === "CREATE_COMPLETE") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,7 +20,7 @@ const checkState = async (client: SchemasClient, input: DescribeCodeBindingComma
         return result.Status;
       };
       if (returnComparator() === "CREATE_IN_PROGRESS") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
     try {
@@ -26,20 +28,20 @@ const checkState = async (client: SchemasClient, input: DescribeCodeBindingComma
         return result.Status;
       };
       if (returnComparator() === "CREATE_FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "NotFoundException") {
-      return { state: WaiterState.FAILURE };
+      return { state: WaiterState.FAILURE, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until code binding is generated
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeCodeBindingCommand for polling.
+ *  @deprecated Use waitUntilCodeBindingExists instead. waitForCodeBindingExists does not throw error in non-success cases.
  */
 export const waitForCodeBindingExists = async (
   params: WaiterConfiguration<SchemasClient>,
@@ -48,3 +50,16 @@ export const waitForCodeBindingExists = async (
   const serviceDefaults = { minDelay: 2, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until code binding is generated
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeCodeBindingCommand for polling.
+ */
+export const waitUntilCodeBindingExists = async (
+  params: WaiterConfiguration<SchemasClient>,
+  input: DescribeCodeBindingCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ses/waiters/waitForIdentityExists.ts b/clients/client-ses/waiters/waitForIdentityExists.ts
index 3eb575e188ead..39c55e5b7224c 100644
--- a/clients/client-ses/waiters/waitForIdentityExists.ts
+++ b/clients/client-ses/waiters/waitForIdentityExists.ts
@@ -3,14 +3,16 @@ import {
   GetIdentityVerificationAttributesCommand,
   GetIdentityVerificationAttributesCommandInput,
 } from "../commands/GetIdentityVerificationAttributesCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: SESClient,
   input: GetIdentityVerificationAttributesCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetIdentityVerificationAttributesCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let objectProjection_2 = Object.values(result.VerificationAttributes).map((element_1: any) => {
@@ -23,16 +25,17 @@ const checkState = async (
         allStringEq_4 = allStringEq_4 && element_3 == "Success";
       }
       if (allStringEq_4) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetIdentityVerificationAttributesCommand for polling.
+ *  @deprecated Use waitUntilIdentityExists instead. waitForIdentityExists does not throw error in non-success cases.
  */
 export const waitForIdentityExists = async (
   params: WaiterConfiguration<SESClient>,
@@ -41,3 +44,16 @@ export const waitForIdentityExists = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetIdentityVerificationAttributesCommand for polling.
+ */
+export const waitUntilIdentityExists = async (
+  params: WaiterConfiguration<SESClient>,
+  input: GetIdentityVerificationAttributesCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-signer/waiters/waitForSuccessfulSigningJob.ts b/clients/client-signer/waiters/waitForSuccessfulSigningJob.ts
index c180799891868..ee116d0c84c2a 100644
--- a/clients/client-signer/waiters/waitForSuccessfulSigningJob.ts
+++ b/clients/client-signer/waiters/waitForSuccessfulSigningJob.ts
@@ -1,16 +1,18 @@
 import { SignerClient } from "../SignerClient";
 import { DescribeSigningJobCommand, DescribeSigningJobCommandInput } from "../commands/DescribeSigningJobCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: SignerClient, input: DescribeSigningJobCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeSigningJobCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.status;
       };
       if (returnComparator() === "Succeeded") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -18,20 +20,20 @@ const checkState = async (client: SignerClient, input: DescribeSigningJobCommand
         return result.status;
       };
       if (returnComparator() === "Failed") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.FAILURE };
+      return { state: WaiterState.FAILURE, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeSigningJobCommand for polling.
+ *  @deprecated Use waitUntilSuccessfulSigningJob instead. waitForSuccessfulSigningJob does not throw error in non-success cases.
  */
 export const waitForSuccessfulSigningJob = async (
   params: WaiterConfiguration<SignerClient>,
@@ -40,3 +42,16 @@ export const waitForSuccessfulSigningJob = async (
   const serviceDefaults = { minDelay: 20, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeSigningJobCommand for polling.
+ */
+export const waitUntilSuccessfulSigningJob = async (
+  params: WaiterConfiguration<SignerClient>,
+  input: DescribeSigningJobCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/clients/client-ssm/waiters/waitForCommandExecuted.ts b/clients/client-ssm/waiters/waitForCommandExecuted.ts
index 3c7d069fe58bd..cbe8d4e5032e3 100644
--- a/clients/client-ssm/waiters/waitForCommandExecuted.ts
+++ b/clients/client-ssm/waiters/waitForCommandExecuted.ts
@@ -1,16 +1,18 @@
 import { SSMClient } from "../SSMClient";
 import { GetCommandInvocationCommand, GetCommandInvocationCommandInput } from "../commands/GetCommandInvocationCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: SSMClient, input: GetCommandInvocationCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetCommandInvocationCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.Status;
       };
       if (returnComparator() === "Pending") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
     try {
@@ -18,7 +20,7 @@ const checkState = async (client: SSMClient, input: GetCommandInvocationCommandI
         return result.Status;
       };
       if (returnComparator() === "InProgress") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
     try {
@@ -26,7 +28,7 @@ const checkState = async (client: SSMClient, input: GetCommandInvocationCommandI
         return result.Status;
       };
       if (returnComparator() === "Delayed") {
-        return { state: WaiterState.RETRY };
+        return { state: WaiterState.RETRY, reason };
       }
     } catch (e) {}
     try {
@@ -34,7 +36,7 @@ const checkState = async (client: SSMClient, input: GetCommandInvocationCommandI
         return result.Status;
       };
       if (returnComparator() === "Success") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -42,7 +44,7 @@ const checkState = async (client: SSMClient, input: GetCommandInvocationCommandI
         return result.Status;
       };
       if (returnComparator() === "Cancelled") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -50,7 +52,7 @@ const checkState = async (client: SSMClient, input: GetCommandInvocationCommandI
         return result.Status;
       };
       if (returnComparator() === "TimedOut") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -58,7 +60,7 @@ const checkState = async (client: SSMClient, input: GetCommandInvocationCommandI
         return result.Status;
       };
       if (returnComparator() === "Failed") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
     try {
@@ -66,16 +68,17 @@ const checkState = async (client: SSMClient, input: GetCommandInvocationCommandI
         return result.Status;
       };
       if (returnComparator() === "Cancelling") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetCommandInvocationCommand for polling.
+ *  @deprecated Use waitUntilCommandExecuted instead. waitForCommandExecuted does not throw error in non-success cases.
  */
 export const waitForCommandExecuted = async (
   params: WaiterConfiguration<SSMClient>,
@@ -84,3 +87,16 @@ export const waitForCommandExecuted = async (
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetCommandInvocationCommand for polling.
+ */
+export const waitUntilCommandExecuted = async (
+  params: WaiterConfiguration<SSMClient>,
+  input: GetCommandInvocationCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
index 0b6c71c650fed..a467d41d2ab65 100644
--- a/packages/types/src/index.ts
+++ b/packages/types/src/index.ts
@@ -13,3 +13,4 @@ export * from "./response";
 export * from "./signature";
 export * from "./transfer";
 export * from "./util";
+export * from "./waiter";
diff --git a/packages/types/src/waiter.ts b/packages/types/src/waiter.ts
new file mode 100644
index 0000000000000..9fba0144f1a8a
--- /dev/null
+++ b/packages/types/src/waiter.ts
@@ -0,0 +1,38 @@
+import { AbortController } from "./abort";
+
+export interface WaiterConfiguration<Client> {
+  /**
+   * Required service client
+   */
+  client: Client;
+
+  /**
+   * The amount of time in seconds a user is willing to wait for a waiter to complete.
+   */
+  maxWaitTime: number;
+
+  /**
+   * @deprecated Use abortSignal
+   * Abort controller. Used for ending the waiter early.
+   */
+  abortController?: AbortController;
+
+  /**
+   * Abort Signal. Used for ending the waiter early.
+   */
+  abortSignal?: AbortController["signal"];
+
+  /**
+   * The minimum amount of time to delay between retries in seconds. This is the
+   * floor of the exponential backoff. This value defaults to service default
+   * if not specified. This value MUST be less than or equal to maxDelay and greater than 0.
+   */
+  minDelay?: number;
+
+  /**
+   * The maximum amount of time to delay between retries in seconds. This is the
+   * ceiling of the exponential backoff. This value defaults to service default
+   * if not specified. If specified, this value MUST be greater than or equal to 1.
+   */
+  maxDelay?: number;
+}
diff --git a/packages/util-waiter/src/createWaiter.ts b/packages/util-waiter/src/createWaiter.ts
index ae0fe46bbb1ee..33f1c6b62095c 100644
--- a/packages/util-waiter/src/createWaiter.ts
+++ b/packages/util-waiter/src/createWaiter.ts
@@ -34,5 +34,10 @@ export const createWaiter = async <Client, Input>(
   if (options.abortController) {
     exitConditions.push(abortTimeout(options.abortController.signal));
   }
+
+  if (options.abortSignal) {
+    exitConditions.push(abortTimeout(options.abortSignal));
+  }
+
   return Promise.race(exitConditions);
 };
diff --git a/packages/util-waiter/src/poller.ts b/packages/util-waiter/src/poller.ts
index c01e261eb0521..f6028d700009e 100644
--- a/packages/util-waiter/src/poller.ts
+++ b/packages/util-waiter/src/poller.ts
@@ -21,7 +21,7 @@ const randomInRange = (min: number, max: number) => min + Math.random() * (max -
  * @param stateChecker function that checks the acceptor states on each poll.
  */
 export const runPolling = async <Client, Input>(
-  { minDelay, maxDelay, maxWaitTime, abortController, client }: WaiterOptions<Client>,
+  { minDelay, maxDelay, maxWaitTime, abortController, client, abortSignal }: WaiterOptions<Client>,
   input: Input,
   acceptorChecks: (client: Client, input: Input) => Promise<WaiterResult>
 ): Promise<WaiterResult> => {
@@ -36,7 +36,7 @@ export const runPolling = async <Client, Input>(
   // Pre-compute this number to avoid Number type overflow.
   const attemptCeiling = Math.log(maxDelay / minDelay) / Math.log(2) + 1;
   while (true) {
-    if (abortController?.signal?.aborted) {
+    if (abortController?.signal?.aborted || abortSignal?.aborted) {
       return { state: WaiterState.ABORTED };
     }
     const delay = exponentialBackoffWithJitter(minDelay, maxDelay, attemptCeiling, currentAttempt);
diff --git a/packages/util-waiter/src/waiter.ts b/packages/util-waiter/src/waiter.ts
index 7383ba1e12fbb..097605e1fa1a6 100644
--- a/packages/util-waiter/src/waiter.ts
+++ b/packages/util-waiter/src/waiter.ts
@@ -1,35 +1,6 @@
-import { AbortController } from "@aws-sdk/types";
+import { WaiterConfiguration as WaiterConfiguration__ } from "@aws-sdk/types";
 
-export interface WaiterConfiguration<Client> {
-  /**
-   * Required service client
-   */
-  client: Client;
-
-  /**
-   * The amount of time in seconds a user is willing to wait for a waiter to complete.
-   */
-  maxWaitTime: number;
-
-  /**
-   * Abort controller. Used for ending the waiter early.
-   */
-  abortController?: AbortController;
-
-  /**
-   * The minimum amount of time to delay between retries in seconds. This is the
-   * floor of the exponential backoff. This value defaults to service default
-   * if not specified. This value MUST be less than or equal to maxDelay and greater than 0.
-   */
-  minDelay?: number;
-
-  /**
-   * The maximum amount of time to delay between retries in seconds. This is the
-   * ceiling of the exponential backoff. This value defaults to service default
-   * if not specified. If specified, this value MUST be greater than or equal to 1.
-   */
-  maxDelay?: number;
-}
+export interface WaiterConfiguration<T> extends WaiterConfiguration__<T> {}
 
 /**
  * @private
@@ -55,4 +26,38 @@ export enum WaiterState {
 
 export type WaiterResult = {
   state: WaiterState;
+
+  /**
+   * (optional) Indicates a reason for why a waiter has reached its state.
+   */
+  reason?: any;
+};
+
+/**
+ * Handles and throws exceptions resulting from the waiterResult
+ * @param result WaiterResult
+ */
+export const checkExceptions = (result: WaiterResult): WaiterResult => {
+  if (result.state === WaiterState.ABORTED) {
+    const abortError = new Error(
+      `${JSON.stringify({
+        ...result,
+        reason: "Request was aborted",
+      })}`
+    );
+    abortError.name = "AbortError";
+    throw abortError;
+  } else if (result.state === WaiterState.TIMEOUT) {
+    const timeoutError = new Error(
+      `${JSON.stringify({
+        ...result,
+        reason: "Waiter has timed out",
+      })}`
+    );
+    timeoutError.name = "TimeoutError";
+    throw timeoutError;
+  } else if (result.state !== WaiterState.SUCCESS) {
+    throw new Error(`${JSON.stringify({ result })}`);
+  }
+  return result;
 };