@aws-sdk/client-ec2 3.1037.0 → 3.1039.0

package/dist-types/ts3.4/waiters/waitForVpnConnectionAvailable.d.ts

@@ -1,11 +1,17 @@
 import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
-import { DescribeVpnConnectionsCommandInput } from "../commands/DescribeVpnConnectionsCommand";
+import {
+  DescribeVpnConnectionsCommandInput,
+  DescribeVpnConnectionsCommandOutput,
+} from "../commands/DescribeVpnConnectionsCommand";
 import { EC2Client } from "../EC2Client";
+import { EC2ServiceException } from "../models/EC2ServiceException";
 export declare const waitForVpnConnectionAvailable: (
   params: WaiterConfiguration<EC2Client>,
   input: DescribeVpnConnectionsCommandInput
-) => Promise<WaiterResult>;
+) => Promise<
+  WaiterResult<DescribeVpnConnectionsCommandOutput | EC2ServiceException>
+>;
 export declare const waitUntilVpnConnectionAvailable: (
   params: WaiterConfiguration<EC2Client>,
   input: DescribeVpnConnectionsCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<DescribeVpnConnectionsCommandOutput>>;

package/dist-types/ts3.4/waiters/waitForVpnConnectionDeleted.d.ts

@@ -1,11 +1,17 @@
 import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
-import { DescribeVpnConnectionsCommandInput } from "../commands/DescribeVpnConnectionsCommand";
+import {
+  DescribeVpnConnectionsCommandInput,
+  DescribeVpnConnectionsCommandOutput,
+} from "../commands/DescribeVpnConnectionsCommand";
 import { EC2Client } from "../EC2Client";
+import { EC2ServiceException } from "../models/EC2ServiceException";
 export declare const waitForVpnConnectionDeleted: (
   params: WaiterConfiguration<EC2Client>,
   input: DescribeVpnConnectionsCommandInput
-) => Promise<WaiterResult>;
+) => Promise<
+  WaiterResult<DescribeVpnConnectionsCommandOutput | EC2ServiceException>
+>;
 export declare const waitUntilVpnConnectionDeleted: (
   params: WaiterConfiguration<EC2Client>,
   input: DescribeVpnConnectionsCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<DescribeVpnConnectionsCommandOutput>>;

package/dist-types/waiters/waitForBundleTaskComplete.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeBundleTasksCommandInput } from "../commands/DescribeBundleTasksCommand";
+import { type DescribeBundleTasksCommandInput, type DescribeBundleTasksCommandOutput } from "../commands/DescribeBundleTasksCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilBundleTaskComplete instead. waitForBundleTaskComplete does not throw error in non-success cases.
  */
-export declare const waitForBundleTaskComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeBundleTasksCommandInput) => Promise<WaiterResult>;
+export declare const waitForBundleTaskComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeBundleTasksCommandInput) => Promise<WaiterResult<DescribeBundleTasksCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeBundleTasksCommand for polling.
  */
-export declare const waitUntilBundleTaskComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeBundleTasksCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilBundleTaskComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeBundleTasksCommandInput) => Promise<WaiterResult<DescribeBundleTasksCommandOutput>>;

package/dist-types/waiters/waitForConversionTaskCancelled.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeConversionTasksCommandInput } from "../commands/DescribeConversionTasksCommand";
+import { type DescribeConversionTasksCommandInput, type DescribeConversionTasksCommandOutput } from "../commands/DescribeConversionTasksCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilConversionTaskCancelled instead. waitForConversionTaskCancelled does not throw error in non-success cases.
  */
-export declare const waitForConversionTaskCancelled: (params: WaiterConfiguration<EC2Client>, input: DescribeConversionTasksCommandInput) => Promise<WaiterResult>;
+export declare const waitForConversionTaskCancelled: (params: WaiterConfiguration<EC2Client>, input: DescribeConversionTasksCommandInput) => Promise<WaiterResult<DescribeConversionTasksCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeConversionTasksCommand for polling.
  */
-export declare const waitUntilConversionTaskCancelled: (params: WaiterConfiguration<EC2Client>, input: DescribeConversionTasksCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilConversionTaskCancelled: (params: WaiterConfiguration<EC2Client>, input: DescribeConversionTasksCommandInput) => Promise<WaiterResult<DescribeConversionTasksCommandOutput>>;

package/dist-types/waiters/waitForConversionTaskCompleted.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeConversionTasksCommandInput } from "../commands/DescribeConversionTasksCommand";
+import { type DescribeConversionTasksCommandInput, type DescribeConversionTasksCommandOutput } from "../commands/DescribeConversionTasksCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilConversionTaskCompleted instead. waitForConversionTaskCompleted does not throw error in non-success cases.
  */
-export declare const waitForConversionTaskCompleted: (params: WaiterConfiguration<EC2Client>, input: DescribeConversionTasksCommandInput) => Promise<WaiterResult>;
+export declare const waitForConversionTaskCompleted: (params: WaiterConfiguration<EC2Client>, input: DescribeConversionTasksCommandInput) => Promise<WaiterResult<DescribeConversionTasksCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeConversionTasksCommand for polling.
  */
-export declare const waitUntilConversionTaskCompleted: (params: WaiterConfiguration<EC2Client>, input: DescribeConversionTasksCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilConversionTaskCompleted: (params: WaiterConfiguration<EC2Client>, input: DescribeConversionTasksCommandInput) => Promise<WaiterResult<DescribeConversionTasksCommandOutput>>;

package/dist-types/waiters/waitForConversionTaskDeleted.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeConversionTasksCommandInput } from "../commands/DescribeConversionTasksCommand";
+import { type DescribeConversionTasksCommandInput, type DescribeConversionTasksCommandOutput } from "../commands/DescribeConversionTasksCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilConversionTaskDeleted instead. waitForConversionTaskDeleted does not throw error in non-success cases.
  */
-export declare const waitForConversionTaskDeleted: (params: WaiterConfiguration<EC2Client>, input: DescribeConversionTasksCommandInput) => Promise<WaiterResult>;
+export declare const waitForConversionTaskDeleted: (params: WaiterConfiguration<EC2Client>, input: DescribeConversionTasksCommandInput) => Promise<WaiterResult<DescribeConversionTasksCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeConversionTasksCommand for polling.
  */
-export declare const waitUntilConversionTaskDeleted: (params: WaiterConfiguration<EC2Client>, input: DescribeConversionTasksCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilConversionTaskDeleted: (params: WaiterConfiguration<EC2Client>, input: DescribeConversionTasksCommandInput) => Promise<WaiterResult<DescribeConversionTasksCommandOutput>>;

package/dist-types/waiters/waitForCustomerGatewayAvailable.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeCustomerGatewaysCommandInput } from "../commands/DescribeCustomerGatewaysCommand";
+import { type DescribeCustomerGatewaysCommandInput, type DescribeCustomerGatewaysCommandOutput } from "../commands/DescribeCustomerGatewaysCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilCustomerGatewayAvailable instead. waitForCustomerGatewayAvailable does not throw error in non-success cases.
  */
-export declare const waitForCustomerGatewayAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeCustomerGatewaysCommandInput) => Promise<WaiterResult>;
+export declare const waitForCustomerGatewayAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeCustomerGatewaysCommandInput) => Promise<WaiterResult<DescribeCustomerGatewaysCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeCustomerGatewaysCommand for polling.
  */
-export declare const waitUntilCustomerGatewayAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeCustomerGatewaysCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilCustomerGatewayAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeCustomerGatewaysCommandInput) => Promise<WaiterResult<DescribeCustomerGatewaysCommandOutput>>;

package/dist-types/waiters/waitForExportTaskCancelled.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeExportTasksCommandInput } from "../commands/DescribeExportTasksCommand";
+import { type DescribeExportTasksCommandInput, type DescribeExportTasksCommandOutput } from "../commands/DescribeExportTasksCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilExportTaskCancelled instead. waitForExportTaskCancelled does not throw error in non-success cases.
  */
-export declare const waitForExportTaskCancelled: (params: WaiterConfiguration<EC2Client>, input: DescribeExportTasksCommandInput) => Promise<WaiterResult>;
+export declare const waitForExportTaskCancelled: (params: WaiterConfiguration<EC2Client>, input: DescribeExportTasksCommandInput) => Promise<WaiterResult<DescribeExportTasksCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeExportTasksCommand for polling.
  */
-export declare const waitUntilExportTaskCancelled: (params: WaiterConfiguration<EC2Client>, input: DescribeExportTasksCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilExportTaskCancelled: (params: WaiterConfiguration<EC2Client>, input: DescribeExportTasksCommandInput) => Promise<WaiterResult<DescribeExportTasksCommandOutput>>;

package/dist-types/waiters/waitForExportTaskCompleted.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeExportTasksCommandInput } from "../commands/DescribeExportTasksCommand";
+import { type DescribeExportTasksCommandInput, type DescribeExportTasksCommandOutput } from "../commands/DescribeExportTasksCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilExportTaskCompleted instead. waitForExportTaskCompleted does not throw error in non-success cases.
  */
-export declare const waitForExportTaskCompleted: (params: WaiterConfiguration<EC2Client>, input: DescribeExportTasksCommandInput) => Promise<WaiterResult>;
+export declare const waitForExportTaskCompleted: (params: WaiterConfiguration<EC2Client>, input: DescribeExportTasksCommandInput) => Promise<WaiterResult<DescribeExportTasksCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeExportTasksCommand for polling.
  */
-export declare const waitUntilExportTaskCompleted: (params: WaiterConfiguration<EC2Client>, input: DescribeExportTasksCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilExportTaskCompleted: (params: WaiterConfiguration<EC2Client>, input: DescribeExportTasksCommandInput) => Promise<WaiterResult<DescribeExportTasksCommandOutput>>;

package/dist-types/waiters/waitForImageAvailable.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeImagesCommandInput } from "../commands/DescribeImagesCommand";
+import { type DescribeImagesCommandInput, type DescribeImagesCommandOutput } from "../commands/DescribeImagesCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilImageAvailable instead. waitForImageAvailable does not throw error in non-success cases.
  */
-export declare const waitForImageAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeImagesCommandInput) => Promise<WaiterResult>;
+export declare const waitForImageAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeImagesCommandInput) => Promise<WaiterResult<DescribeImagesCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeImagesCommand for polling.
  */
-export declare const waitUntilImageAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeImagesCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilImageAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeImagesCommandInput) => Promise<WaiterResult<DescribeImagesCommandOutput>>;

package/dist-types/waiters/waitForImageExists.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeImagesCommandInput } from "../commands/DescribeImagesCommand";
+import { type DescribeImagesCommandInput, type DescribeImagesCommandOutput } from "../commands/DescribeImagesCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilImageExists instead. waitForImageExists does not throw error in non-success cases.
  */
-export declare const waitForImageExists: (params: WaiterConfiguration<EC2Client>, input: DescribeImagesCommandInput) => Promise<WaiterResult>;
+export declare const waitForImageExists: (params: WaiterConfiguration<EC2Client>, input: DescribeImagesCommandInput) => Promise<WaiterResult<DescribeImagesCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeImagesCommand for polling.
  */
-export declare const waitUntilImageExists: (params: WaiterConfiguration<EC2Client>, input: DescribeImagesCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilImageExists: (params: WaiterConfiguration<EC2Client>, input: DescribeImagesCommandInput) => Promise<WaiterResult<DescribeImagesCommandOutput>>;

package/dist-types/waiters/waitForImageUsageReportAvailable.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeImageUsageReportsCommandInput } from "../commands/DescribeImageUsageReportsCommand";
+import { type DescribeImageUsageReportsCommandInput, type DescribeImageUsageReportsCommandOutput } from "../commands/DescribeImageUsageReportsCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilImageUsageReportAvailable instead. waitForImageUsageReportAvailable does not throw error in non-success cases.
  */
-export declare const waitForImageUsageReportAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeImageUsageReportsCommandInput) => Promise<WaiterResult>;
+export declare const waitForImageUsageReportAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeImageUsageReportsCommandInput) => Promise<WaiterResult<DescribeImageUsageReportsCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeImageUsageReportsCommand for polling.
  */
-export declare const waitUntilImageUsageReportAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeImageUsageReportsCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilImageUsageReportAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeImageUsageReportsCommandInput) => Promise<WaiterResult<DescribeImageUsageReportsCommandOutput>>;

package/dist-types/waiters/waitForInstanceExists.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeInstancesCommandInput } from "../commands/DescribeInstancesCommand";
+import { type DescribeInstancesCommandInput, type DescribeInstancesCommandOutput } from "../commands/DescribeInstancesCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilInstanceExists instead. waitForInstanceExists does not throw error in non-success cases.
  */
-export declare const waitForInstanceExists: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult>;
+export declare const waitForInstanceExists: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult<DescribeInstancesCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeInstancesCommand for polling.
  */
-export declare const waitUntilInstanceExists: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilInstanceExists: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult<DescribeInstancesCommandOutput>>;

package/dist-types/waiters/waitForInstanceRunning.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeInstancesCommandInput } from "../commands/DescribeInstancesCommand";
+import { type DescribeInstancesCommandInput, type DescribeInstancesCommandOutput } from "../commands/DescribeInstancesCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilInstanceRunning instead. waitForInstanceRunning does not throw error in non-success cases.
  */
-export declare const waitForInstanceRunning: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult>;
+export declare const waitForInstanceRunning: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult<DescribeInstancesCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeInstancesCommand for polling.
  */
-export declare const waitUntilInstanceRunning: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilInstanceRunning: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult<DescribeInstancesCommandOutput>>;

package/dist-types/waiters/waitForInstanceStatusOk.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeInstanceStatusCommandInput } from "../commands/DescribeInstanceStatusCommand";
+import { type DescribeInstanceStatusCommandInput, type DescribeInstanceStatusCommandOutput } from "../commands/DescribeInstanceStatusCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilInstanceStatusOk instead. waitForInstanceStatusOk does not throw error in non-success cases.
  */
-export declare const waitForInstanceStatusOk: (params: WaiterConfiguration<EC2Client>, input: DescribeInstanceStatusCommandInput) => Promise<WaiterResult>;
+export declare const waitForInstanceStatusOk: (params: WaiterConfiguration<EC2Client>, input: DescribeInstanceStatusCommandInput) => Promise<WaiterResult<DescribeInstanceStatusCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeInstanceStatusCommand for polling.
  */
-export declare const waitUntilInstanceStatusOk: (params: WaiterConfiguration<EC2Client>, input: DescribeInstanceStatusCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilInstanceStatusOk: (params: WaiterConfiguration<EC2Client>, input: DescribeInstanceStatusCommandInput) => Promise<WaiterResult<DescribeInstanceStatusCommandOutput>>;

package/dist-types/waiters/waitForInstanceStopped.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeInstancesCommandInput } from "../commands/DescribeInstancesCommand";
+import { type DescribeInstancesCommandInput, type DescribeInstancesCommandOutput } from "../commands/DescribeInstancesCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilInstanceStopped instead. waitForInstanceStopped does not throw error in non-success cases.
  */
-export declare const waitForInstanceStopped: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult>;
+export declare const waitForInstanceStopped: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult<DescribeInstancesCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeInstancesCommand for polling.
  */
-export declare const waitUntilInstanceStopped: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilInstanceStopped: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult<DescribeInstancesCommandOutput>>;

package/dist-types/waiters/waitForInstanceTerminated.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeInstancesCommandInput } from "../commands/DescribeInstancesCommand";
+import { type DescribeInstancesCommandInput, type DescribeInstancesCommandOutput } from "../commands/DescribeInstancesCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilInstanceTerminated instead. waitForInstanceTerminated does not throw error in non-success cases.
  */
-export declare const waitForInstanceTerminated: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult>;
+export declare const waitForInstanceTerminated: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult<DescribeInstancesCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeInstancesCommand for polling.
  */
-export declare const waitUntilInstanceTerminated: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilInstanceTerminated: (params: WaiterConfiguration<EC2Client>, input: DescribeInstancesCommandInput) => Promise<WaiterResult<DescribeInstancesCommandOutput>>;

package/dist-types/waiters/waitForInternetGatewayExists.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeInternetGatewaysCommandInput } from "../commands/DescribeInternetGatewaysCommand";
+import { type DescribeInternetGatewaysCommandInput, type DescribeInternetGatewaysCommandOutput } from "../commands/DescribeInternetGatewaysCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilInternetGatewayExists instead. waitForInternetGatewayExists does not throw error in non-success cases.
  */
-export declare const waitForInternetGatewayExists: (params: WaiterConfiguration<EC2Client>, input: DescribeInternetGatewaysCommandInput) => Promise<WaiterResult>;
+export declare const waitForInternetGatewayExists: (params: WaiterConfiguration<EC2Client>, input: DescribeInternetGatewaysCommandInput) => Promise<WaiterResult<DescribeInternetGatewaysCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeInternetGatewaysCommand for polling.
  */
-export declare const waitUntilInternetGatewayExists: (params: WaiterConfiguration<EC2Client>, input: DescribeInternetGatewaysCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilInternetGatewayExists: (params: WaiterConfiguration<EC2Client>, input: DescribeInternetGatewaysCommandInput) => Promise<WaiterResult<DescribeInternetGatewaysCommandOutput>>;

package/dist-types/waiters/waitForKeyPairExists.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeKeyPairsCommandInput } from "../commands/DescribeKeyPairsCommand";
+import { type DescribeKeyPairsCommandInput, type DescribeKeyPairsCommandOutput } from "../commands/DescribeKeyPairsCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilKeyPairExists instead. waitForKeyPairExists does not throw error in non-success cases.
  */
-export declare const waitForKeyPairExists: (params: WaiterConfiguration<EC2Client>, input: DescribeKeyPairsCommandInput) => Promise<WaiterResult>;
+export declare const waitForKeyPairExists: (params: WaiterConfiguration<EC2Client>, input: DescribeKeyPairsCommandInput) => Promise<WaiterResult<DescribeKeyPairsCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeKeyPairsCommand for polling.
  */
-export declare const waitUntilKeyPairExists: (params: WaiterConfiguration<EC2Client>, input: DescribeKeyPairsCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilKeyPairExists: (params: WaiterConfiguration<EC2Client>, input: DescribeKeyPairsCommandInput) => Promise<WaiterResult<DescribeKeyPairsCommandOutput>>;

package/dist-types/waiters/waitForNatGatewayAvailable.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeNatGatewaysCommandInput } from "../commands/DescribeNatGatewaysCommand";
+import { type DescribeNatGatewaysCommandInput, type DescribeNatGatewaysCommandOutput } from "../commands/DescribeNatGatewaysCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilNatGatewayAvailable instead. waitForNatGatewayAvailable does not throw error in non-success cases.
  */
-export declare const waitForNatGatewayAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeNatGatewaysCommandInput) => Promise<WaiterResult>;
+export declare const waitForNatGatewayAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeNatGatewaysCommandInput) => Promise<WaiterResult<DescribeNatGatewaysCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeNatGatewaysCommand for polling.
  */
-export declare const waitUntilNatGatewayAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeNatGatewaysCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilNatGatewayAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeNatGatewaysCommandInput) => Promise<WaiterResult<DescribeNatGatewaysCommandOutput>>;

package/dist-types/waiters/waitForNatGatewayDeleted.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeNatGatewaysCommandInput } from "../commands/DescribeNatGatewaysCommand";
+import { type DescribeNatGatewaysCommandInput, type DescribeNatGatewaysCommandOutput } from "../commands/DescribeNatGatewaysCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilNatGatewayDeleted instead. waitForNatGatewayDeleted does not throw error in non-success cases.
  */
-export declare const waitForNatGatewayDeleted: (params: WaiterConfiguration<EC2Client>, input: DescribeNatGatewaysCommandInput) => Promise<WaiterResult>;
+export declare const waitForNatGatewayDeleted: (params: WaiterConfiguration<EC2Client>, input: DescribeNatGatewaysCommandInput) => Promise<WaiterResult<DescribeNatGatewaysCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeNatGatewaysCommand for polling.
  */
-export declare const waitUntilNatGatewayDeleted: (params: WaiterConfiguration<EC2Client>, input: DescribeNatGatewaysCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilNatGatewayDeleted: (params: WaiterConfiguration<EC2Client>, input: DescribeNatGatewaysCommandInput) => Promise<WaiterResult<DescribeNatGatewaysCommandOutput | EC2ServiceException>>;

package/dist-types/waiters/waitForNetworkInterfaceAvailable.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeNetworkInterfacesCommandInput } from "../commands/DescribeNetworkInterfacesCommand";
+import { type DescribeNetworkInterfacesCommandInput, type DescribeNetworkInterfacesCommandOutput } from "../commands/DescribeNetworkInterfacesCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilNetworkInterfaceAvailable instead. waitForNetworkInterfaceAvailable does not throw error in non-success cases.
  */
-export declare const waitForNetworkInterfaceAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeNetworkInterfacesCommandInput) => Promise<WaiterResult>;
+export declare const waitForNetworkInterfaceAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeNetworkInterfacesCommandInput) => Promise<WaiterResult<DescribeNetworkInterfacesCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeNetworkInterfacesCommand for polling.
  */
-export declare const waitUntilNetworkInterfaceAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeNetworkInterfacesCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilNetworkInterfaceAvailable: (params: WaiterConfiguration<EC2Client>, input: DescribeNetworkInterfacesCommandInput) => Promise<WaiterResult<DescribeNetworkInterfacesCommandOutput>>;

package/dist-types/waiters/waitForPasswordDataAvailable.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type GetPasswordDataCommandInput } from "../commands/GetPasswordDataCommand";
+import { type GetPasswordDataCommandInput, type GetPasswordDataCommandOutput } from "../commands/GetPasswordDataCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilPasswordDataAvailable instead. waitForPasswordDataAvailable does not throw error in non-success cases.
  */
-export declare const waitForPasswordDataAvailable: (params: WaiterConfiguration<EC2Client>, input: GetPasswordDataCommandInput) => Promise<WaiterResult>;
+export declare const waitForPasswordDataAvailable: (params: WaiterConfiguration<EC2Client>, input: GetPasswordDataCommandInput) => Promise<WaiterResult<GetPasswordDataCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to GetPasswordDataCommand for polling.
  */
-export declare const waitUntilPasswordDataAvailable: (params: WaiterConfiguration<EC2Client>, input: GetPasswordDataCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilPasswordDataAvailable: (params: WaiterConfiguration<EC2Client>, input: GetPasswordDataCommandInput) => Promise<WaiterResult<GetPasswordDataCommandOutput>>;

package/dist-types/waiters/waitForSecondaryNetworkCreateComplete.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeSecondaryNetworksCommandInput } from "../commands/DescribeSecondaryNetworksCommand";
+import { type DescribeSecondaryNetworksCommandInput, type DescribeSecondaryNetworksCommandOutput } from "../commands/DescribeSecondaryNetworksCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilSecondaryNetworkCreateComplete instead. waitForSecondaryNetworkCreateComplete does not throw error in non-success cases.
  */
-export declare const waitForSecondaryNetworkCreateComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondaryNetworksCommandInput) => Promise<WaiterResult>;
+export declare const waitForSecondaryNetworkCreateComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondaryNetworksCommandInput) => Promise<WaiterResult<DescribeSecondaryNetworksCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeSecondaryNetworksCommand for polling.
  */
-export declare const waitUntilSecondaryNetworkCreateComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondaryNetworksCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilSecondaryNetworkCreateComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondaryNetworksCommandInput) => Promise<WaiterResult<DescribeSecondaryNetworksCommandOutput>>;

package/dist-types/waiters/waitForSecondaryNetworkDeleteComplete.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeSecondaryNetworksCommandInput } from "../commands/DescribeSecondaryNetworksCommand";
+import { type DescribeSecondaryNetworksCommandInput, type DescribeSecondaryNetworksCommandOutput } from "../commands/DescribeSecondaryNetworksCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilSecondaryNetworkDeleteComplete instead. waitForSecondaryNetworkDeleteComplete does not throw error in non-success cases.
  */
-export declare const waitForSecondaryNetworkDeleteComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondaryNetworksCommandInput) => Promise<WaiterResult>;
+export declare const waitForSecondaryNetworkDeleteComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondaryNetworksCommandInput) => Promise<WaiterResult<DescribeSecondaryNetworksCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeSecondaryNetworksCommand for polling.
  */
-export declare const waitUntilSecondaryNetworkDeleteComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondaryNetworksCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilSecondaryNetworkDeleteComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondaryNetworksCommandInput) => Promise<WaiterResult<DescribeSecondaryNetworksCommandOutput>>;

package/dist-types/waiters/waitForSecondarySubnetCreateComplete.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeSecondarySubnetsCommandInput } from "../commands/DescribeSecondarySubnetsCommand";
+import { type DescribeSecondarySubnetsCommandInput, type DescribeSecondarySubnetsCommandOutput } from "../commands/DescribeSecondarySubnetsCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilSecondarySubnetCreateComplete instead. waitForSecondarySubnetCreateComplete does not throw error in non-success cases.
  */
-export declare const waitForSecondarySubnetCreateComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondarySubnetsCommandInput) => Promise<WaiterResult>;
+export declare const waitForSecondarySubnetCreateComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondarySubnetsCommandInput) => Promise<WaiterResult<DescribeSecondarySubnetsCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeSecondarySubnetsCommand for polling.
  */
-export declare const waitUntilSecondarySubnetCreateComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondarySubnetsCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilSecondarySubnetCreateComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondarySubnetsCommandInput) => Promise<WaiterResult<DescribeSecondarySubnetsCommandOutput>>;

package/dist-types/waiters/waitForSecondarySubnetDeleteComplete.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeSecondarySubnetsCommandInput } from "../commands/DescribeSecondarySubnetsCommand";
+import { type DescribeSecondarySubnetsCommandInput, type DescribeSecondarySubnetsCommandOutput } from "../commands/DescribeSecondarySubnetsCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilSecondarySubnetDeleteComplete instead. waitForSecondarySubnetDeleteComplete does not throw error in non-success cases.
  */
-export declare const waitForSecondarySubnetDeleteComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondarySubnetsCommandInput) => Promise<WaiterResult>;
+export declare const waitForSecondarySubnetDeleteComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondarySubnetsCommandInput) => Promise<WaiterResult<DescribeSecondarySubnetsCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeSecondarySubnetsCommand for polling.
  */
-export declare const waitUntilSecondarySubnetDeleteComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondarySubnetsCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilSecondarySubnetDeleteComplete: (params: WaiterConfiguration<EC2Client>, input: DescribeSecondarySubnetsCommandInput) => Promise<WaiterResult<DescribeSecondarySubnetsCommandOutput>>;

package/dist-types/waiters/waitForSecurityGroupExists.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeSecurityGroupsCommandInput } from "../commands/DescribeSecurityGroupsCommand";
+import { type DescribeSecurityGroupsCommandInput, type DescribeSecurityGroupsCommandOutput } from "../commands/DescribeSecurityGroupsCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilSecurityGroupExists instead. waitForSecurityGroupExists does not throw error in non-success cases.
  */
-export declare const waitForSecurityGroupExists: (params: WaiterConfiguration<EC2Client>, input: DescribeSecurityGroupsCommandInput) => Promise<WaiterResult>;
+export declare const waitForSecurityGroupExists: (params: WaiterConfiguration<EC2Client>, input: DescribeSecurityGroupsCommandInput) => Promise<WaiterResult<DescribeSecurityGroupsCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeSecurityGroupsCommand for polling.
  */
-export declare const waitUntilSecurityGroupExists: (params: WaiterConfiguration<EC2Client>, input: DescribeSecurityGroupsCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilSecurityGroupExists: (params: WaiterConfiguration<EC2Client>, input: DescribeSecurityGroupsCommandInput) => Promise<WaiterResult<DescribeSecurityGroupsCommandOutput>>;

package/dist-types/waiters/waitForSecurityGroupVpcAssociationAssociated.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type DescribeSecurityGroupVpcAssociationsCommandInput } from "../commands/DescribeSecurityGroupVpcAssociationsCommand";
+import { type DescribeSecurityGroupVpcAssociationsCommandInput, type DescribeSecurityGroupVpcAssociationsCommandOutput } from "../commands/DescribeSecurityGroupVpcAssociationsCommand";
 import type { EC2Client } from "../EC2Client";
+import type { EC2ServiceException } from "../models/EC2ServiceException";
 /**
  *
  *  @deprecated Use waitUntilSecurityGroupVpcAssociationAssociated instead. waitForSecurityGroupVpcAssociationAssociated does not throw error in non-success cases.
  */
-export declare const waitForSecurityGroupVpcAssociationAssociated: (params: WaiterConfiguration<EC2Client>, input: DescribeSecurityGroupVpcAssociationsCommandInput) => Promise<WaiterResult>;
+export declare const waitForSecurityGroupVpcAssociationAssociated: (params: WaiterConfiguration<EC2Client>, input: DescribeSecurityGroupVpcAssociationsCommandInput) => Promise<WaiterResult<DescribeSecurityGroupVpcAssociationsCommandOutput | EC2ServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to DescribeSecurityGroupVpcAssociationsCommand for polling.
  */
-export declare const waitUntilSecurityGroupVpcAssociationAssociated: (params: WaiterConfiguration<EC2Client>, input: DescribeSecurityGroupVpcAssociationsCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilSecurityGroupVpcAssociationAssociated: (params: WaiterConfiguration<EC2Client>, input: DescribeSecurityGroupVpcAssociationsCommandInput) => Promise<WaiterResult<DescribeSecurityGroupVpcAssociationsCommandOutput>>;