@aws-sdk/client-ec2 3.284.0 → 3.288.0

package/dist-es/pagination/DescribeImportImageTasksPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeImportImageTasksCommand, } from "../commands/DescribeImportImageTasksCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeImportImageTasksCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeImportImageTasks(input, ...args);
-};
 export async function* paginateDescribeImportImageTasks(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeImportImageTasks(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/DescribeImportSnapshotTasksPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeImportSnapshotTasksCommand, } from "../commands/DescribeImportSnapshotTasksCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeImportSnapshotTasksCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeImportSnapshotTasks(input, ...args);
-};
 export async function* paginateDescribeImportSnapshotTasks(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeImportSnapshotTasks(config, input, ...add
     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/DescribeInstanceCreditSpecificationsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeInstanceCreditSpecificationsCommand, } from "../commands/DescribeInstanceCreditSpecificationsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeInstanceCreditSpecificationsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeInstanceCreditSpecifications(input, ...args);
-};
 export async function* paginateDescribeInstanceCreditSpecifications(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeInstanceCreditSpecifications(config, inpu
     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/DescribeInstanceEventWindowsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeInstanceEventWindowsCommand, } from "../commands/DescribeInstanceEventWindowsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeInstanceEventWindowsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeInstanceEventWindows(input, ...args);
-};
 export async function* paginateDescribeInstanceEventWindows(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeInstanceEventWindows(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/DescribeInstanceStatusPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeInstanceStatusCommand, } from "../commands/DescribeInstanceStatusCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeInstanceStatusCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeInstanceStatus(input, ...args);
-};
 export async function* paginateDescribeInstanceStatus(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeInstanceStatus(config, input, ...addition
     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/DescribeInstanceTypeOfferingsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeInstanceTypeOfferingsCommand, } from "../commands/DescribeInstanceTypeOfferingsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeInstanceTypeOfferingsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeInstanceTypeOfferings(input, ...args);
-};
 export async function* paginateDescribeInstanceTypeOfferings(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeInstanceTypeOfferings(config, input, ...a
     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/DescribeInstanceTypesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeInstanceTypesCommand, } from "../commands/DescribeInstanceTypesCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeInstanceTypesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeInstanceTypes(input, ...args);
-};
 export async function* paginateDescribeInstanceTypes(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeInstanceTypes(config, input, ...additiona
     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/DescribeInstancesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeInstancesCommand, } from "../commands/DescribeInstancesCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeInstancesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeInstances(input, ...args);
-};
 export async function* paginateDescribeInstances(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeInstances(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/DescribeInternetGatewaysPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeInternetGatewaysCommand, } from "../commands/DescribeInternetGatewaysCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeInternetGatewaysCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeInternetGateways(input, ...args);
-};
 export async function* paginateDescribeInternetGateways(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeInternetGateways(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/DescribeIpamPoolsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeIpamPoolsCommand, } from "../commands/DescribeIpamPoolsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeIpamPoolsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeIpamPools(input, ...args);
-};
 export async function* paginateDescribeIpamPools(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeIpamPools(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/DescribeIpamResourceDiscoveriesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeIpamResourceDiscoveriesCommand, } from "../commands/DescribeIpamResourceDiscoveriesCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeIpamResourceDiscoveriesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeIpamResourceDiscoveries(input, ...args);
-};
 export async function* paginateDescribeIpamResourceDiscoveries(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeIpamResourceDiscoveries(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/DescribeIpamResourceDiscoveryAssociationsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeIpamResourceDiscoveryAssociationsCommand, } from "../commands/DescribeIpamResourceDiscoveryAssociationsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeIpamResourceDiscoveryAssociationsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeIpamResourceDiscoveryAssociations(input, ...args);
-};
 export async function* paginateDescribeIpamResourceDiscoveryAssociations(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeIpamResourceDiscoveryAssociations(config,
     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/DescribeIpamScopesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeIpamScopesCommand, } from "../commands/DescribeIpamScopesCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeIpamScopesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeIpamScopes(input, ...args);
-};
 export async function* paginateDescribeIpamScopes(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeIpamScopes(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/DescribeIpamsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeIpamsCommand, } from "../commands/DescribeIpamsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeIpamsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeIpams(input, ...args);
-};
 export async function* paginateDescribeIpams(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeIpams(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 {

package/dist-es/pagination/DescribeIpv6PoolsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeIpv6PoolsCommand, } from "../commands/DescribeIpv6PoolsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeIpv6PoolsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeIpv6Pools(input, ...args);
-};
 export async function* paginateDescribeIpv6Pools(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeIpv6Pools(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/DescribeLaunchTemplateVersionsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeLaunchTemplateVersionsCommand, } from "../commands/DescribeLaunchTemplateVersionsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeLaunchTemplateVersionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeLaunchTemplateVersions(input, ...args);
-};
 export async function* paginateDescribeLaunchTemplateVersions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeLaunchTemplateVersions(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/DescribeLaunchTemplatesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeLaunchTemplatesCommand, } from "../commands/DescribeLaunchTemplatesCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeLaunchTemplatesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeLaunchTemplates(input, ...args);
-};
 export async function* paginateDescribeLaunchTemplates(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeLaunchTemplates(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/DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsCommand, } from "../commands/DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(input, ...args);
-};
 export async function* paginateDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeLocalGatewayRouteTableVirtualInterfaceGro
     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/DescribeLocalGatewayRouteTableVpcAssociationsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeLocalGatewayRouteTableVpcAssociationsCommand, } from "../commands/DescribeLocalGatewayRouteTableVpcAssociationsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeLocalGatewayRouteTableVpcAssociationsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeLocalGatewayRouteTableVpcAssociations(input, ...args);
-};
 export async function* paginateDescribeLocalGatewayRouteTableVpcAssociations(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeLocalGatewayRouteTableVpcAssociations(con
     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/DescribeLocalGatewayRouteTablesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeLocalGatewayRouteTablesCommand, } from "../commands/DescribeLocalGatewayRouteTablesCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeLocalGatewayRouteTablesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeLocalGatewayRouteTables(input, ...args);
-};
 export async function* paginateDescribeLocalGatewayRouteTables(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeLocalGatewayRouteTables(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/DescribeLocalGatewayVirtualInterfaceGroupsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeLocalGatewayVirtualInterfaceGroupsCommand, } from "../commands/DescribeLocalGatewayVirtualInterfaceGroupsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeLocalGatewayVirtualInterfaceGroupsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeLocalGatewayVirtualInterfaceGroups(input, ...args);
-};
 export async function* paginateDescribeLocalGatewayVirtualInterfaceGroups(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeLocalGatewayVirtualInterfaceGroups(config
     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/DescribeLocalGatewayVirtualInterfacesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeLocalGatewayVirtualInterfacesCommand, } from "../commands/DescribeLocalGatewayVirtualInterfacesCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeLocalGatewayVirtualInterfacesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeLocalGatewayVirtualInterfaces(input, ...args);
-};
 export async function* paginateDescribeLocalGatewayVirtualInterfaces(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeLocalGatewayVirtualInterfaces(config, inp
     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/DescribeLocalGatewaysPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeLocalGatewaysCommand, } from "../commands/DescribeLocalGatewaysCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeLocalGatewaysCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeLocalGateways(input, ...args);
-};
 export async function* paginateDescribeLocalGateways(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeLocalGateways(config, input, ...additiona
     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/DescribeManagedPrefixListsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeManagedPrefixListsCommand, } from "../commands/DescribeManagedPrefixListsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeManagedPrefixListsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeManagedPrefixLists(input, ...args);
-};
 export async function* paginateDescribeManagedPrefixLists(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeManagedPrefixLists(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/DescribeMovingAddressesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeMovingAddressesCommand, } from "../commands/DescribeMovingAddressesCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeMovingAddressesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeMovingAddresses(input, ...args);
-};
 export async function* paginateDescribeMovingAddresses(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeMovingAddresses(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 {