@cdklabs/cdk-ssm-documents 0.0.58 → 0.0.60

package/node_modules/@aws-sdk/client-ec2/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/node_modules/@aws-sdk/client-ec2/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>>;

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForSecurityGroupVpcAssociationDisassociated.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 waitUntilSecurityGroupVpcAssociationDisassociated instead. waitForSecurityGroupVpcAssociationDisassociated does not throw error in non-success cases.
  */
-export declare const waitForSecurityGroupVpcAssociationDisassociated: (params: WaiterConfiguration<EC2Client>, input: DescribeSecurityGroupVpcAssociationsCommandInput) => Promise<WaiterResult>;
+export declare const waitForSecurityGroupVpcAssociationDisassociated: (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 waitUntilSecurityGroupVpcAssociationDisassociated: (params: WaiterConfiguration<EC2Client>, input: DescribeSecurityGroupVpcAssociationsCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilSecurityGroupVpcAssociationDisassociated: (params: WaiterConfiguration<EC2Client>, input: DescribeSecurityGroupVpcAssociationsCommandInput) => Promise<WaiterResult<DescribeSecurityGroupVpcAssociationsCommandOutput>>;

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForSnapshotCompleted.d.ts

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

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForSnapshotImported.d.ts

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

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForSpotInstanceRequestFulfilled.d.ts

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

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForStoreImageTaskComplete.d.ts

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

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForSubnetAvailable.d.ts

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

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForSystemStatusOk.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 waitUntilSystemStatusOk instead. waitForSystemStatusOk does not throw error in non-success cases.
  */
-export declare const waitForSystemStatusOk: (params: WaiterConfiguration<EC2Client>, input: DescribeInstanceStatusCommandInput) => Promise<WaiterResult>;
+export declare const waitForSystemStatusOk: (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 waitUntilSystemStatusOk: (params: WaiterConfiguration<EC2Client>, input: DescribeInstanceStatusCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilSystemStatusOk: (params: WaiterConfiguration<EC2Client>, input: DescribeInstanceStatusCommandInput) => Promise<WaiterResult<DescribeInstanceStatusCommandOutput>>;

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForVolumeAvailable.d.ts

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

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForVolumeDeleted.d.ts

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

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForVolumeInUse.d.ts

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

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForVpcAvailable.d.ts

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

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForVpcExists.d.ts

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

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForVpcPeeringConnectionDeleted.d.ts

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

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForVpcPeeringConnectionExists.d.ts

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

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForVpnConnectionAvailable.d.ts

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

package/node_modules/@aws-sdk/client-ec2/dist-types/waiters/waitForVpnConnectionDeleted.d.ts

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

package/node_modules/@aws-sdk/client-ec2/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-ec2",
   "description": "AWS SDK for JavaScript Ec2 Client for Node.js, Browser and React Native",
-  "version": "3.1037.0",
+  "version": "3.1045.0",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
     "build:cjs": "node ../../scripts/compilation/inline client-ec2",
@@ -25,18 +25,18 @@
   "dependencies": {
     "@aws-crypto/sha256-browser": "5.2.0",
     "@aws-crypto/sha256-js": "5.2.0",
-    "@aws-sdk/core": "^3.974.5",
-    "@aws-sdk/credential-provider-node": "^3.972.36",
+    "@aws-sdk/core": "^3.974.8",
+    "@aws-sdk/credential-provider-node": "^3.972.39",
     "@aws-sdk/middleware-host-header": "^3.972.10",
     "@aws-sdk/middleware-logger": "^3.972.10",
     "@aws-sdk/middleware-recursion-detection": "^3.972.11",
     "@aws-sdk/middleware-sdk-ec2": "^3.972.22",
-    "@aws-sdk/middleware-user-agent": "^3.972.35",
+    "@aws-sdk/middleware-user-agent": "^3.972.38",
     "@aws-sdk/region-config-resolver": "^3.972.13",
     "@aws-sdk/types": "^3.973.8",
     "@aws-sdk/util-endpoints": "^3.996.8",
     "@aws-sdk/util-user-agent-browser": "^3.972.10",
-    "@aws-sdk/util-user-agent-node": "^3.973.21",
+    "@aws-sdk/util-user-agent-node": "^3.973.24",
     "@smithy/config-resolver": "^4.4.17",
     "@smithy/core": "^3.23.17",
     "@smithy/fetch-http-handler": "^5.3.17",
@@ -44,7 +44,7 @@
     "@smithy/invalid-dependency": "^4.2.14",
     "@smithy/middleware-content-length": "^4.2.14",
     "@smithy/middleware-endpoint": "^4.4.32",
-    "@smithy/middleware-retry": "^4.5.5",
+    "@smithy/middleware-retry": "^4.5.7",
     "@smithy/middleware-serde": "^4.2.20",
     "@smithy/middleware-stack": "^4.2.14",
     "@smithy/node-config-provider": "^4.3.14",
@@ -60,9 +60,9 @@
     "@smithy/util-defaults-mode-node": "^4.2.54",
     "@smithy/util-endpoints": "^3.4.2",
     "@smithy/util-middleware": "^4.2.14",
-    "@smithy/util-retry": "^4.3.4",
+    "@smithy/util-retry": "^4.3.6",
     "@smithy/util-utf8": "^4.2.2",
-    "@smithy/util-waiter": "^4.2.16",
+    "@smithy/util-waiter": "^4.3.0",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

package/node_modules/@aws-sdk/client-iam/README.md

@@ -11,6 +11,57 @@ AWS SDK for JavaScript IAM Client for Node.js, Browser and React Native.
 access to Amazon Web Services services. With IAM, you can centrally manage users, security credentials
 such as access keys, and permissions that control which Amazon Web Services resources users and
 applications can access. For more information about IAM, see <a href="http://aws.amazon.com/iam/">Identity and Access Management (IAM)</a> and the <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/">Identity and Access Management User Guide</a>.</p>
+<p>
+<b>Programmatic access to IAM</b>
+</p>
+<p>We recommend that you use the Amazon Web Services SDKs to make programmatic API calls to IAM. The Amazon Web Services
+SDKs consist of libraries and sample code for various programming languages and platforms
+(for example, Java, Ruby, .NET, iOS, and Android). The SDKs provide a convenient way to
+create programmatic access to IAM and Amazon Web Services. For example, the SDKs take care of tasks such as
+cryptographically signing requests, managing errors, and retrying requests automatically.
+For more information, see <a href="http://aws.amazon.com/tools/">Tools to build on
+Amazon Web Services</a>.</p>
+<p>Alternatively, you can also use the IAM Query API to make direct calls to the IAM
+service. For more information about calling the IAM Query API, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html">Making query
+requests</a> in the <i>Identity and Access Management User Guide</i>. IAM supports GET and
+POST requests for all actions. That is, the API does not require you to use GET for some
+actions and POST for others. However, GET requests are subject to the limitation size of a
+URL. Therefore, for operations that require larger sizes, use a POST request.</p>
+<p>
+<b>Signing requests</b>
+</p>
+<p>Requests must be signed using an access key ID and a secret access key. We strongly
+recommend that you do not use your Amazon Web Services account access key ID and secret access key for
+everyday work with IAM. You can use the access key ID and secret access key for an
+IAM user or you can use the Security Token Service to generate temporary security credentials and use
+those to sign requests.</p>
+<p>To sign requests, we recommend that you use <a href="https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html">Signature Version 4</a>. If you have an
+existing application that uses Signature Version 2, you do not have to update it to use
+Signature Version 4. However, some operations now require Signature Version 4. The
+documentation for operations that require version 4 indicate this requirement.</p>
+<p>
+<b>Additional resources</b>
+</p>
+<ul>
+<li>
+<p>
+<a href="https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html">Amazon Web Services
+security credentials</a>. This topic provides general information about the types of
+credentials used for accessing Amazon Web Services.</p>
+</li>
+<li>
+<p>
+<a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPractices.html">IAM best
+practices</a>. This topic presents a list of suggestions for using the IAM service
+to help secure your Amazon Web Services resources.</p>
+</li>
+<li>
+<p>
+<a href="https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html">Signing
+Amazon Web Services API requests</a>. This set of topics walk you through the process of signing a
+request using an access key ID and secret access key.</p>
+</li>
+</ul>
 
 ## Installing
 

package/node_modules/@aws-sdk/client-iam/dist-cjs/index.js

@@ -2303,7 +2303,7 @@ const checkState$3 = async (client, input) => {
     }
     catch (exception) {
         reason = exception;
-        if (exception.name && exception.name == "NoSuchEntityException") {
+        if (exception.name === "NoSuchEntityException") {
             return { state: utilWaiter.WaiterState.RETRY, reason };
         }
     }
@@ -2328,7 +2328,7 @@ const checkState$2 = async (client, input) => {
     }
     catch (exception) {
         reason = exception;
-        if (exception.name && exception.name == "NoSuchEntityException") {
+        if (exception.name === "NoSuchEntityException") {
             return { state: utilWaiter.WaiterState.RETRY, reason };
         }
     }
@@ -2353,7 +2353,7 @@ const checkState$1 = async (client, input) => {
     }
     catch (exception) {
         reason = exception;
-        if (exception.name && exception.name == "NoSuchEntityException") {
+        if (exception.name === "NoSuchEntityException") {
             return { state: utilWaiter.WaiterState.RETRY, reason };
         }
     }
@@ -2378,7 +2378,7 @@ const checkState = async (client, input) => {
     }
     catch (exception) {
         reason = exception;
-        if (exception.name && exception.name == "NoSuchEntityException") {
+        if (exception.name === "NoSuchEntityException") {
             return { state: utilWaiter.WaiterState.RETRY, reason };
         }
     }

package/node_modules/@aws-sdk/client-iam/dist-es/waiters/waitForInstanceProfileExists.js

@@ -1,5 +1,5 @@
 import { checkExceptions, createWaiter, WaiterState, } from "@smithy/util-waiter";
-import { GetInstanceProfileCommand } from "../commands/GetInstanceProfileCommand";
+import { GetInstanceProfileCommand, } from "../commands/GetInstanceProfileCommand";
 const checkState = async (client, input) => {
     let reason;
     try {
@@ -9,7 +9,7 @@ const checkState = async (client, input) => {
     }
     catch (exception) {
         reason = exception;
-        if (exception.name && exception.name == "NoSuchEntityException") {
+        if (exception.name === "NoSuchEntityException") {
             return { state: WaiterState.RETRY, reason };
         }
     }

package/node_modules/@aws-sdk/client-iam/dist-es/waiters/waitForPolicyExists.js

@@ -1,5 +1,5 @@
 import { checkExceptions, createWaiter, WaiterState, } from "@smithy/util-waiter";
-import { GetPolicyCommand } from "../commands/GetPolicyCommand";
+import { GetPolicyCommand, } from "../commands/GetPolicyCommand";
 const checkState = async (client, input) => {
     let reason;
     try {
@@ -9,7 +9,7 @@ const checkState = async (client, input) => {
     }
     catch (exception) {
         reason = exception;
-        if (exception.name && exception.name == "NoSuchEntityException") {
+        if (exception.name === "NoSuchEntityException") {
             return { state: WaiterState.RETRY, reason };
         }
     }

package/node_modules/@aws-sdk/client-iam/dist-es/waiters/waitForRoleExists.js

@@ -9,7 +9,7 @@ const checkState = async (client, input) => {
     }
     catch (exception) {
         reason = exception;
-        if (exception.name && exception.name == "NoSuchEntityException") {
+        if (exception.name === "NoSuchEntityException") {
             return { state: WaiterState.RETRY, reason };
         }
     }

package/node_modules/@aws-sdk/client-iam/dist-es/waiters/waitForUserExists.js

@@ -9,7 +9,7 @@ const checkState = async (client, input) => {
     }
     catch (exception) {
         reason = exception;
-        if (exception.name && exception.name == "NoSuchEntityException") {
+        if (exception.name === "NoSuchEntityException") {
             return { state: WaiterState.RETRY, reason };
         }
     }