@aws-sdk/client-ec2 3.284.0 → 3.287.0

package/dist-es/pagination/DescribeVpcClassicLinkDnsSupportPaginator.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist-es/pagination/GetIpamResourceCidrsPaginator.js

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

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

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

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

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

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

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

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