@aws-sdk/client-ec2 3.282.0 → 3.287.0

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 {

package/dist-es/pagination/DescribeNatGatewaysPaginator.js

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,22 +1,15 @@
 import { DescribeReservedInstancesModificationsCommand, } from "../commands/DescribeReservedInstancesModificationsCommand";
-import { EC2 } from "../EC2";
 import { EC2Client } from "../EC2Client";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeReservedInstancesModificationsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeReservedInstancesModifications(input, ...args);
-};
 export async function* paginateDescribeReservedInstancesModifications(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.NextToken = token;
-        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/DescribeReservedInstancesOfferingsPaginator.js

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

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

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

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

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

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

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

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

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

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