@aws-sdk/client-ec2 3.842.0 → 3.843.0

package/dist-cjs/index.js

@@ -1360,6 +1360,8 @@ __export(index_exports, {
   waitForNetworkInterfaceAvailable: () => waitForNetworkInterfaceAvailable,
   waitForPasswordDataAvailable: () => waitForPasswordDataAvailable,
   waitForSecurityGroupExists: () => waitForSecurityGroupExists,
+  waitForSecurityGroupVpcAssociationAssociated: () => waitForSecurityGroupVpcAssociationAssociated,
+  waitForSecurityGroupVpcAssociationDisassociated: () => waitForSecurityGroupVpcAssociationDisassociated,
   waitForSnapshotCompleted: () => waitForSnapshotCompleted,
   waitForSnapshotImported: () => waitForSnapshotImported,
   waitForSpotInstanceRequestFulfilled: () => waitForSpotInstanceRequestFulfilled,
@@ -1396,6 +1398,8 @@ __export(index_exports, {
   waitUntilNetworkInterfaceAvailable: () => waitUntilNetworkInterfaceAvailable,
   waitUntilPasswordDataAvailable: () => waitUntilPasswordDataAvailable,
   waitUntilSecurityGroupExists: () => waitUntilSecurityGroupExists,
+  waitUntilSecurityGroupVpcAssociationAssociated: () => waitUntilSecurityGroupVpcAssociationAssociated,
+  waitUntilSecurityGroupVpcAssociationDisassociated: () => waitUntilSecurityGroupVpcAssociationDisassociated,
   waitUntilSnapshotCompleted: () => waitUntilSnapshotCompleted,
   waitUntilSnapshotImported: () => waitUntilSnapshotImported,
   waitUntilSpotInstanceRequestFulfilled: () => waitUntilSpotInstanceRequestFulfilled,
@@ -58350,6 +58354,9 @@ var de_SecurityGroupVpcAssociation = /* @__PURE__ */ __name((output, context) =>
   if (output[_sRt] != null) {
     contents[_SRt] = (0, import_smithy_client.expectString)(output[_sRt]);
   }
+  if (output[_gOI] != null) {
+    contents[_GOI] = (0, import_smithy_client.expectString)(output[_gOI]);
+  }
   return contents;
 }, "de_SecurityGroupVpcAssociation");
 var de_SecurityGroupVpcAssociationList = /* @__PURE__ */ __name((output, context) => {
@@ -84033,9 +84040,157 @@ var waitUntilSecurityGroupExists = /* @__PURE__ */ __name(async (params, input)
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilSecurityGroupExists");
 
-// src/waiters/waitForSnapshotCompleted.ts
+// src/waiters/waitForSecurityGroupVpcAssociationAssociated.ts
 
 var checkState22 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeSecurityGroupVpcAssociationsCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.State;
+        });
+        return projection_3;
+      }, "returnComparator");
+      let allStringEq_5 = returnComparator().length > 0;
+      for (const element_4 of returnComparator()) {
+        allStringEq_5 = allStringEq_5 && element_4 == "associated";
+      }
+      if (allStringEq_5) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.State;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "associating") {
+          return { state: import_util_waiter.WaiterState.RETRY, reason };
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.State;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "association-failed") {
+          return { state: import_util_waiter.WaiterState.FAILURE, reason };
+        }
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForSecurityGroupVpcAssociationAssociated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState22);
+}, "waitForSecurityGroupVpcAssociationAssociated");
+var waitUntilSecurityGroupVpcAssociationAssociated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState22);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilSecurityGroupVpcAssociationAssociated");
+
+// src/waiters/waitForSecurityGroupVpcAssociationDisassociated.ts
+
+var checkState23 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeSecurityGroupVpcAssociationsCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.State;
+        });
+        return projection_3;
+      }, "returnComparator");
+      let allStringEq_5 = returnComparator().length > 0;
+      for (const element_4 of returnComparator()) {
+        allStringEq_5 = allStringEq_5 && element_4 == "disassociated";
+      }
+      if (allStringEq_5) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.State;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "disassociating") {
+          return { state: import_util_waiter.WaiterState.RETRY, reason };
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.State;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "disassociation-failed") {
+          return { state: import_util_waiter.WaiterState.FAILURE, reason };
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+        return flat_1.length == 0;
+      }, "returnComparator");
+      if (returnComparator() == true) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForSecurityGroupVpcAssociationDisassociated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState23);
+}, "waitForSecurityGroupVpcAssociationDisassociated");
+var waitUntilSecurityGroupVpcAssociationDisassociated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState23);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilSecurityGroupVpcAssociationDisassociated");
+
+// src/waiters/waitForSnapshotCompleted.ts
+
+var checkState24 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new DescribeSnapshotsCommand(input));
@@ -84079,17 +84234,17 @@ var checkState22 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForSnapshotCompleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState22);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState24);
 }, "waitForSnapshotCompleted");
 var waitUntilSnapshotCompleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState22);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState24);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilSnapshotCompleted");
 
 // src/waiters/waitForSpotInstanceRequestFulfilled.ts
 
-var checkState23 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState25 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new DescribeSpotInstanceRequestsCommand(input));
@@ -84198,17 +84353,56 @@ var checkState23 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForSpotInstanceRequestFulfilled = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState23);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState25);
 }, "waitForSpotInstanceRequestFulfilled");
 var waitUntilSpotInstanceRequestFulfilled = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState23);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState25);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilSpotInstanceRequestFulfilled");
 
+// src/waiters/waitForSystemStatusOk.ts
+
+var checkState26 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeInstanceStatusCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.InstanceStatuses);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.SystemStatus.Status;
+        });
+        return projection_3;
+      }, "returnComparator");
+      let allStringEq_5 = returnComparator().length > 0;
+      for (const element_4 of returnComparator()) {
+        allStringEq_5 = allStringEq_5 && element_4 == "ok";
+      }
+      if (allStringEq_5) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForSystemStatusOk = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState26);
+}, "waitForSystemStatusOk");
+var waitUntilSystemStatusOk = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState26);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilSystemStatusOk");
+
 // src/waiters/waitForStoreImageTaskComplete.ts
 
-var checkState24 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState27 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new DescribeStoreImageTasksCommand(input));
@@ -84267,34 +84461,26 @@ var checkState24 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForStoreImageTaskComplete = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState24);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState27);
 }, "waitForStoreImageTaskComplete");
 var waitUntilStoreImageTaskComplete = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState24);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState27);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilStoreImageTaskComplete");
 
-// src/waiters/waitForSubnetAvailable.ts
+// src/waiters/waitForPasswordDataAvailable.ts
 
-var checkState25 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState28 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
-    const result = await client.send(new DescribeSubnetsCommand(input));
+    const result = await client.send(new GetPasswordDataCommand(input));
     reason = result;
     try {
       const returnComparator = /* @__PURE__ */ __name(() => {
-        const flat_1 = [].concat(...result.Subnets);
-        const projection_3 = flat_1.map((element_2) => {
-          return element_2.State;
-        });
-        return projection_3;
+        return result.PasswordData.length > 0;
       }, "returnComparator");
-      let allStringEq_5 = returnComparator().length > 0;
-      for (const element_4 of returnComparator()) {
-        allStringEq_5 = allStringEq_5 && element_4 == "available";
-      }
-      if (allStringEq_5) {
+      if (returnComparator() == true) {
         return { state: import_util_waiter.WaiterState.SUCCESS, reason };
       }
     } catch (e) {
@@ -84304,34 +84490,34 @@ var checkState25 = /* @__PURE__ */ __name(async (client, input) => {
   }
   return { state: import_util_waiter.WaiterState.RETRY, reason };
 }, "checkState");
-var waitForSubnetAvailable = /* @__PURE__ */ __name(async (params, input) => {
+var waitForPasswordDataAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState25);
-}, "waitForSubnetAvailable");
-var waitUntilSubnetAvailable = /* @__PURE__ */ __name(async (params, input) => {
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState28);
+}, "waitForPasswordDataAvailable");
+var waitUntilPasswordDataAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState25);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState28);
   return (0, import_util_waiter.checkExceptions)(result);
-}, "waitUntilSubnetAvailable");
+}, "waitUntilPasswordDataAvailable");
 
-// src/waiters/waitForSystemStatusOk.ts
+// src/waiters/waitForSubnetAvailable.ts
 
-var checkState26 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState29 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
-    const result = await client.send(new DescribeInstanceStatusCommand(input));
+    const result = await client.send(new DescribeSubnetsCommand(input));
     reason = result;
     try {
       const returnComparator = /* @__PURE__ */ __name(() => {
-        const flat_1 = [].concat(...result.InstanceStatuses);
+        const flat_1 = [].concat(...result.Subnets);
         const projection_3 = flat_1.map((element_2) => {
-          return element_2.SystemStatus.Status;
+          return element_2.State;
         });
         return projection_3;
       }, "returnComparator");
       let allStringEq_5 = returnComparator().length > 0;
       for (const element_4 of returnComparator()) {
-        allStringEq_5 = allStringEq_5 && element_4 == "ok";
+        allStringEq_5 = allStringEq_5 && element_4 == "available";
       }
       if (allStringEq_5) {
         return { state: import_util_waiter.WaiterState.SUCCESS, reason };
@@ -84343,50 +84529,19 @@ var checkState26 = /* @__PURE__ */ __name(async (client, input) => {
   }
   return { state: import_util_waiter.WaiterState.RETRY, reason };
 }, "checkState");
-var waitForSystemStatusOk = /* @__PURE__ */ __name(async (params, input) => {
-  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState26);
-}, "waitForSystemStatusOk");
-var waitUntilSystemStatusOk = /* @__PURE__ */ __name(async (params, input) => {
-  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState26);
-  return (0, import_util_waiter.checkExceptions)(result);
-}, "waitUntilSystemStatusOk");
-
-// src/waiters/waitForPasswordDataAvailable.ts
-
-var checkState27 = /* @__PURE__ */ __name(async (client, input) => {
-  let reason;
-  try {
-    const result = await client.send(new GetPasswordDataCommand(input));
-    reason = result;
-    try {
-      const returnComparator = /* @__PURE__ */ __name(() => {
-        return result.PasswordData.length > 0;
-      }, "returnComparator");
-      if (returnComparator() == true) {
-        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
-      }
-    } catch (e) {
-    }
-  } catch (exception) {
-    reason = exception;
-  }
-  return { state: import_util_waiter.WaiterState.RETRY, reason };
-}, "checkState");
-var waitForPasswordDataAvailable = /* @__PURE__ */ __name(async (params, input) => {
+var waitForSubnetAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState27);
-}, "waitForPasswordDataAvailable");
-var waitUntilPasswordDataAvailable = /* @__PURE__ */ __name(async (params, input) => {
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState29);
+}, "waitForSubnetAvailable");
+var waitUntilSubnetAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState27);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState29);
   return (0, import_util_waiter.checkExceptions)(result);
-}, "waitUntilPasswordDataAvailable");
+}, "waitUntilSubnetAvailable");
 
 // src/waiters/waitForVolumeAvailable.ts
 
-var checkState28 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState30 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new DescribeVolumesCommand(input));
@@ -84430,17 +84585,17 @@ var checkState28 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForVolumeAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState28);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState30);
 }, "waitForVolumeAvailable");
 var waitUntilVolumeAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState28);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState30);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilVolumeAvailable");
 
 // src/waiters/waitForVolumeDeleted.ts
 
-var checkState29 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState31 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new DescribeVolumesCommand(input));
@@ -84472,17 +84627,17 @@ var checkState29 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForVolumeDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState29);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState31);
 }, "waitForVolumeDeleted");
 var waitUntilVolumeDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState29);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState31);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilVolumeDeleted");
 
 // src/waiters/waitForVolumeInUse.ts
 
-var checkState30 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState32 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new DescribeVolumesCommand(input));
@@ -84526,17 +84681,17 @@ var checkState30 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForVolumeInUse = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState30);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState32);
 }, "waitForVolumeInUse");
 var waitUntilVolumeInUse = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState30);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState32);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilVolumeInUse");
 
 // src/waiters/waitForVpcAvailable.ts
 
-var checkState31 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState33 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new DescribeVpcsCommand(input));
@@ -84565,17 +84720,17 @@ var checkState31 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForVpcAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState31);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState33);
 }, "waitForVpcAvailable");
 var waitUntilVpcAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState31);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState33);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilVpcAvailable");
 
 // src/waiters/waitForVpcExists.ts
 
-var checkState32 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState34 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new DescribeVpcsCommand(input));
@@ -84591,17 +84746,17 @@ var checkState32 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForVpcExists = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 1, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState32);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState34);
 }, "waitForVpcExists");
 var waitUntilVpcExists = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 1, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState32);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState34);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilVpcExists");
 
 // src/waiters/waitForVpcPeeringConnectionDeleted.ts
 
-var checkState33 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState35 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new DescribeVpcPeeringConnectionsCommand(input));
@@ -84633,17 +84788,17 @@ var checkState33 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForVpcPeeringConnectionDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState33);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState35);
 }, "waitForVpcPeeringConnectionDeleted");
 var waitUntilVpcPeeringConnectionDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState33);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState35);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilVpcPeeringConnectionDeleted");
 
 // src/waiters/waitForVpcPeeringConnectionExists.ts
 
-var checkState34 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState36 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new DescribeVpcPeeringConnectionsCommand(input));
@@ -84659,17 +84814,17 @@ var checkState34 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForVpcPeeringConnectionExists = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState34);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState36);
 }, "waitForVpcPeeringConnectionExists");
 var waitUntilVpcPeeringConnectionExists = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState34);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState36);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilVpcPeeringConnectionExists");
 
 // src/waiters/waitForVpnConnectionAvailable.ts
 
-var checkState35 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState37 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new DescribeVpnConnectionsCommand(input));
@@ -84728,17 +84883,17 @@ var checkState35 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForVpnConnectionAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState35);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState37);
 }, "waitForVpnConnectionAvailable");
 var waitUntilVpnConnectionAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState35);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState37);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilVpnConnectionAvailable");
 
 // src/waiters/waitForVpnConnectionDeleted.ts
 
-var checkState36 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState38 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new DescribeVpnConnectionsCommand(input));
@@ -84782,11 +84937,11 @@ var checkState36 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForVpnConnectionDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState36);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState38);
 }, "waitForVpnConnectionDeleted");
 var waitUntilVpnConnectionDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState36);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState38);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilVpnConnectionDeleted");
 // Annotate the CommonJS export names for ESM import in node:
@@ -85674,18 +85829,22 @@ var waitUntilVpnConnectionDeleted = /* @__PURE__ */ __name(async (params, input)
   waitUntilSnapshotImported,
   waitForSecurityGroupExists,
   waitUntilSecurityGroupExists,
+  waitForSecurityGroupVpcAssociationAssociated,
+  waitUntilSecurityGroupVpcAssociationAssociated,
+  waitForSecurityGroupVpcAssociationDisassociated,
+  waitUntilSecurityGroupVpcAssociationDisassociated,
   waitForSnapshotCompleted,
   waitUntilSnapshotCompleted,
   waitForSpotInstanceRequestFulfilled,
   waitUntilSpotInstanceRequestFulfilled,
-  waitForStoreImageTaskComplete,
-  waitUntilStoreImageTaskComplete,
-  waitForSubnetAvailable,
-  waitUntilSubnetAvailable,
   waitForSystemStatusOk,
   waitUntilSystemStatusOk,
+  waitForStoreImageTaskComplete,
+  waitUntilStoreImageTaskComplete,
   waitForPasswordDataAvailable,
   waitUntilPasswordDataAvailable,
+  waitForSubnetAvailable,
+  waitUntilSubnetAvailable,
   waitForVolumeAvailable,
   waitUntilVolumeAvailable,
   waitForVolumeDeleted,

package/dist-es/protocols/Aws_ec2.js

@@ -57925,6 +57925,9 @@ const de_SecurityGroupVpcAssociation = (output, context) => {
     if (output[_sRt] != null) {
         contents[_SRt] = __expectString(output[_sRt]);
     }
+    if (output[_gOI] != null) {
+        contents[_GOI] = __expectString(output[_gOI]);
+    }
     return contents;
 };
 const de_SecurityGroupVpcAssociationList = (output, context) => {

package/dist-es/waiters/index.js

@@ -19,12 +19,14 @@ export * from "./waitForNatGatewayDeleted";
 export * from "./waitForNetworkInterfaceAvailable";
 export * from "./waitForSnapshotImported";
 export * from "./waitForSecurityGroupExists";
+export * from "./waitForSecurityGroupVpcAssociationAssociated";
+export * from "./waitForSecurityGroupVpcAssociationDisassociated";
 export * from "./waitForSnapshotCompleted";
 export * from "./waitForSpotInstanceRequestFulfilled";
-export * from "./waitForStoreImageTaskComplete";
-export * from "./waitForSubnetAvailable";
 export * from "./waitForSystemStatusOk";
+export * from "./waitForStoreImageTaskComplete";
 export * from "./waitForPasswordDataAvailable";
+export * from "./waitForSubnetAvailable";
 export * from "./waitForVolumeAvailable";
 export * from "./waitForVolumeDeleted";
 export * from "./waitForVolumeInUse";

package/dist-es/waiters/waitForSecurityGroupVpcAssociationAssociated.js

@@ -0,0 +1,69 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeSecurityGroupVpcAssociationsCommand, } from "../commands/DescribeSecurityGroupVpcAssociationsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeSecurityGroupVpcAssociationsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "associated";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "associating") {
+                    return { state: WaiterState.RETRY, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "association-failed") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForSecurityGroupVpcAssociationAssociated = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilSecurityGroupVpcAssociationAssociated = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForSecurityGroupVpcAssociationDisassociated.js

@@ -0,0 +1,79 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeSecurityGroupVpcAssociationsCommand, } from "../commands/DescribeSecurityGroupVpcAssociationsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeSecurityGroupVpcAssociationsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "disassociated";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "disassociating") {
+                    return { state: WaiterState.RETRY, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "disassociation-failed") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SecurityGroupVpcAssociations);
+                return flat_1.length == 0.0;
+            };
+            if (returnComparator() == true) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForSecurityGroupVpcAssociationDisassociated = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilSecurityGroupVpcAssociationDisassociated = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-types/commands/AssociateSecurityGroupVpcCommand.d.ts

@@ -37,7 +37,7 @@ declare const AssociateSecurityGroupVpcCommand_base: {
  *                   <p>You can associate the security group with another VPC if your account owns the VPC or if the VPC was shared with you.</p>
  *                </li>
  *                <li>
- *                   <p>You must own the security group and the VPC that it was created in.</p>
+ *                   <p>You must own the security group.</p>
  *                </li>
  *                <li>
  *                   <p>You cannot use this feature with default security groups.</p>

package/dist-types/commands/DescribeSecurityGroupVpcAssociationsCommand.d.ts

@@ -57,6 +57,7 @@ declare const DescribeSecurityGroupVpcAssociationsCommand_base: {
  * //       VpcOwnerId: "STRING_VALUE",
  * //       State: "associating" || "associated" || "association-failed" || "disassociating" || "disassociated" || "disassociation-failed",
  * //       StateReason: "STRING_VALUE",
+ * //       GroupOwnerId: "STRING_VALUE",
  * //     },
  * //   ],
  * //   NextToken: "STRING_VALUE",

package/dist-types/models/models_5.d.ts

@@ -4947,6 +4947,10 @@ export interface DescribeSecurityGroupVpcAssociationsRequest {
      *             </li>
      *             <li>
      *                <p>
+     *                   <code>group-owner-id</code>: The group owner ID.</p>
+     *             </li>
+     *             <li>
+     *                <p>
      *                   <code>vpc-id</code>: The ID of the associated VPC.</p>
      *             </li>
      *             <li>
@@ -5023,6 +5027,11 @@ export interface SecurityGroupVpcAssociation {
      * @public
      */
     StateReason?: string | undefined;
+    /**
+     * <p>The Amazon Web Services account ID of the owner of the security group.</p>
+     * @public
+     */
+    GroupOwnerId?: string | undefined;
 }
 /**
  * @public

package/dist-types/ts3.4/models/models_5.d.ts

@@ -948,6 +948,7 @@ export interface SecurityGroupVpcAssociation {
   VpcOwnerId?: string | undefined;
   State?: SecurityGroupVpcAssociationState | undefined;
   StateReason?: string | undefined;
+  GroupOwnerId?: string | undefined;
 }
 export interface DescribeSecurityGroupVpcAssociationsResult {
   SecurityGroupVpcAssociations?: SecurityGroupVpcAssociation[] | undefined;

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

@@ -19,12 +19,14 @@ export * from "./waitForNatGatewayDeleted";
 export * from "./waitForNetworkInterfaceAvailable";
 export * from "./waitForSnapshotImported";
 export * from "./waitForSecurityGroupExists";
+export * from "./waitForSecurityGroupVpcAssociationAssociated";
+export * from "./waitForSecurityGroupVpcAssociationDisassociated";
 export * from "./waitForSnapshotCompleted";
 export * from "./waitForSpotInstanceRequestFulfilled";
-export * from "./waitForStoreImageTaskComplete";
-export * from "./waitForSubnetAvailable";
 export * from "./waitForSystemStatusOk";
+export * from "./waitForStoreImageTaskComplete";
 export * from "./waitForPasswordDataAvailable";
+export * from "./waitForSubnetAvailable";
 export * from "./waitForVolumeAvailable";
 export * from "./waitForVolumeDeleted";
 export * from "./waitForVolumeInUse";

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

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { DescribeSecurityGroupVpcAssociationsCommandInput } from "../commands/DescribeSecurityGroupVpcAssociationsCommand";
+import { EC2Client } from "../EC2Client";
+export declare const waitForSecurityGroupVpcAssociationAssociated: (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeSecurityGroupVpcAssociationsCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilSecurityGroupVpcAssociationAssociated: (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeSecurityGroupVpcAssociationsCommandInput
+) => Promise<WaiterResult>;

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

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { DescribeSecurityGroupVpcAssociationsCommandInput } from "../commands/DescribeSecurityGroupVpcAssociationsCommand";
+import { EC2Client } from "../EC2Client";
+export declare const waitForSecurityGroupVpcAssociationDisassociated: (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeSecurityGroupVpcAssociationsCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilSecurityGroupVpcAssociationDisassociated: (
+  params: WaiterConfiguration<EC2Client>,
+  input: DescribeSecurityGroupVpcAssociationsCommandInput
+) => Promise<WaiterResult>;

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

@@ -19,12 +19,14 @@ export * from "./waitForNatGatewayDeleted";
 export * from "./waitForNetworkInterfaceAvailable";
 export * from "./waitForSnapshotImported";
 export * from "./waitForSecurityGroupExists";
+export * from "./waitForSecurityGroupVpcAssociationAssociated";
+export * from "./waitForSecurityGroupVpcAssociationDisassociated";
 export * from "./waitForSnapshotCompleted";
 export * from "./waitForSpotInstanceRequestFulfilled";
-export * from "./waitForStoreImageTaskComplete";
-export * from "./waitForSubnetAvailable";
 export * from "./waitForSystemStatusOk";
+export * from "./waitForStoreImageTaskComplete";
 export * from "./waitForPasswordDataAvailable";
+export * from "./waitForSubnetAvailable";
 export * from "./waitForVolumeAvailable";
 export * from "./waitForVolumeDeleted";
 export * from "./waitForVolumeInUse";

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

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

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

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

package/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.842.0",
+  "version": "3.843.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "node ../../scripts/compilation/inline client-ec2",