@aws-sdk/client-ec2 3.284.0 → 3.287.0

package/dist-es/pagination/DescribeStoreImageTasksPaginator.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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