@aws-sdk/client-ec2 3.282.0 → 3.287.0

package/dist-es/models/models_7.js

@@ -1,3 +1,6 @@
+export const TerminateInstancesResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const UnassignIpv6AddressesRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });

package/dist-es/pagination/DescribeAddressTransfersPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeAddressTransfersCommand, } from "../commands/DescribeAddressTransfersCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeAddressTransfersCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeAddressTransfers(input, ...args);
-};
 export async function* paginateDescribeAddressTransfers(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeAddressTransfers(config, input, ...additi
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeAddressesAttributePaginator.js

@@ -1,12 +1,8 @@
 import { DescribeAddressesAttributeCommand, } from "../commands/DescribeAddressesAttributeCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeAddressesAttributeCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeAddressesAttribute(input, ...args);
-};
 export async function* paginateDescribeAddressesAttribute(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeAddressesAttribute(config, input, ...addi
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeAwsNetworkPerformanceMetricSubscriptionsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeAwsNetworkPerformanceMetricSubscriptionsCommand, } from "../commands/DescribeAwsNetworkPerformanceMetricSubscriptionsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeAwsNetworkPerformanceMetricSubscriptionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeAwsNetworkPerformanceMetricSubscriptions(input, ...args);
-};
 export async function* paginateDescribeAwsNetworkPerformanceMetricSubscriptions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeAwsNetworkPerformanceMetricSubscriptions(
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeByoipCidrsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeByoipCidrsCommand, } from "../commands/DescribeByoipCidrsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeByoipCidrsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeByoipCidrs(input, ...args);
-};
 export async function* paginateDescribeByoipCidrs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeByoipCidrs(config, input, ...additionalAr
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeCapacityReservationFleetsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeCapacityReservationFleetsCommand, } from "../commands/DescribeCapacityReservationFleetsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeCapacityReservationFleetsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeCapacityReservationFleets(input, ...args);
-};
 export async function* paginateDescribeCapacityReservationFleets(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeCapacityReservationFleets(config, input,
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeCapacityReservationsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeCapacityReservationsCommand, } from "../commands/DescribeCapacityReservationsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeCapacityReservationsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeCapacityReservations(input, ...args);
-};
 export async function* paginateDescribeCapacityReservations(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeCapacityReservations(config, input, ...ad
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeCarrierGatewaysPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeCarrierGatewaysCommand, } from "../commands/DescribeCarrierGatewaysCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeCarrierGatewaysCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeCarrierGateways(input, ...args);
-};
 export async function* paginateDescribeCarrierGateways(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeCarrierGateways(config, input, ...additio
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeClassicLinkInstancesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeClassicLinkInstancesCommand, } from "../commands/DescribeClassicLinkInstancesCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeClassicLinkInstancesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeClassicLinkInstances(input, ...args);
-};
 export async function* paginateDescribeClassicLinkInstances(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeClassicLinkInstances(config, input, ...ad
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeClientVpnAuthorizationRulesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeClientVpnAuthorizationRulesCommand, } from "../commands/DescribeClientVpnAuthorizationRulesCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeClientVpnAuthorizationRulesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeClientVpnAuthorizationRules(input, ...args);
-};
 export async function* paginateDescribeClientVpnAuthorizationRules(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeClientVpnAuthorizationRules(config, input
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeClientVpnConnectionsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeClientVpnConnectionsCommand, } from "../commands/DescribeClientVpnConnectionsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeClientVpnConnectionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeClientVpnConnections(input, ...args);
-};
 export async function* paginateDescribeClientVpnConnections(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeClientVpnConnections(config, input, ...ad
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeClientVpnEndpointsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeClientVpnEndpointsCommand, } from "../commands/DescribeClientVpnEndpointsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeClientVpnEndpointsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeClientVpnEndpoints(input, ...args);
-};
 export async function* paginateDescribeClientVpnEndpoints(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeClientVpnEndpoints(config, input, ...addi
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeClientVpnRoutesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeClientVpnRoutesCommand, } from "../commands/DescribeClientVpnRoutesCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeClientVpnRoutesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeClientVpnRoutes(input, ...args);
-};
 export async function* paginateDescribeClientVpnRoutes(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeClientVpnRoutes(config, input, ...additio
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeClientVpnTargetNetworksPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeClientVpnTargetNetworksCommand, } from "../commands/DescribeClientVpnTargetNetworksCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeClientVpnTargetNetworksCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeClientVpnTargetNetworks(input, ...args);
-};
 export async function* paginateDescribeClientVpnTargetNetworks(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeClientVpnTargetNetworks(config, input, ..
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeCoipPoolsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeCoipPoolsCommand, } from "../commands/DescribeCoipPoolsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeCoipPoolsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeCoipPools(input, ...args);
-};
 export async function* paginateDescribeCoipPools(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeCoipPools(config, input, ...additionalArg
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeDhcpOptionsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDhcpOptionsCommand, } from "../commands/DescribeDhcpOptionsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDhcpOptionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDhcpOptions(input, ...args);
-};
 export async function* paginateDescribeDhcpOptions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDhcpOptions(config, input, ...additionalA
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeEgressOnlyInternetGatewaysPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeEgressOnlyInternetGatewaysCommand, } from "../commands/DescribeEgressOnlyInternetGatewaysCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeEgressOnlyInternetGatewaysCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeEgressOnlyInternetGateways(input, ...args);
-};
 export async function* paginateDescribeEgressOnlyInternetGateways(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeEgressOnlyInternetGateways(config, input,
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeExportImageTasksPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeExportImageTasksCommand, } from "../commands/DescribeExportImageTasksCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeExportImageTasksCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeExportImageTasks(input, ...args);
-};
 export async function* paginateDescribeExportImageTasks(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeExportImageTasks(config, input, ...additi
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeFastLaunchImagesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeFastLaunchImagesCommand, } from "../commands/DescribeFastLaunchImagesCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeFastLaunchImagesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeFastLaunchImages(input, ...args);
-};
 export async function* paginateDescribeFastLaunchImages(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeFastLaunchImages(config, input, ...additi
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeFastSnapshotRestoresPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeFastSnapshotRestoresCommand, } from "../commands/DescribeFastSnapshotRestoresCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeFastSnapshotRestoresCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeFastSnapshotRestores(input, ...args);
-};
 export async function* paginateDescribeFastSnapshotRestores(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeFastSnapshotRestores(config, input, ...ad
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeFleetsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeFleetsCommand, } from "../commands/DescribeFleetsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeFleetsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeFleets(input, ...args);
-};
 export async function* paginateDescribeFleets(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeFleets(config, input, ...additionalArgume
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeFlowLogsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeFlowLogsCommand, } from "../commands/DescribeFlowLogsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeFlowLogsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeFlowLogs(input, ...args);
-};
 export async function* paginateDescribeFlowLogs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeFlowLogs(config, input, ...additionalArgu
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeFpgaImagesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeFpgaImagesCommand, } from "../commands/DescribeFpgaImagesCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeFpgaImagesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeFpgaImages(input, ...args);
-};
 export async function* paginateDescribeFpgaImages(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeFpgaImages(config, input, ...additionalAr
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeHostReservationOfferingsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeHostReservationOfferingsCommand, } from "../commands/DescribeHostReservationOfferingsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeHostReservationOfferingsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeHostReservationOfferings(input, ...args);
-};
 export async function* paginateDescribeHostReservationOfferings(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeHostReservationOfferings(config, input, .
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeHostReservationsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeHostReservationsCommand, } from "../commands/DescribeHostReservationsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeHostReservationsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeHostReservations(input, ...args);
-};
 export async function* paginateDescribeHostReservations(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeHostReservations(config, input, ...additi
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeHostsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeHostsCommand, } from "../commands/DescribeHostsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeHostsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeHosts(input, ...args);
-};
 export async function* paginateDescribeHosts(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeHosts(config, input, ...additionalArgumen
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof EC2) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof EC2Client) {
+        if (config.client instanceof EC2Client) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {