@aws-sdk/client-ec2 3.43.0 → 3.44.0

package/dist-es/models/models_6.js

@@ -0,0 +1,209 @@
+import { __assign } from "tslib";
+export var LaunchTemplateSpecification;
+(function (LaunchTemplateSpecification) {
+    LaunchTemplateSpecification.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(LaunchTemplateSpecification || (LaunchTemplateSpecification = {}));
+export var LicenseConfigurationRequest;
+(function (LicenseConfigurationRequest) {
+    LicenseConfigurationRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(LicenseConfigurationRequest || (LicenseConfigurationRequest = {}));
+export var InstanceMetadataOptionsRequest;
+(function (InstanceMetadataOptionsRequest) {
+    InstanceMetadataOptionsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(InstanceMetadataOptionsRequest || (InstanceMetadataOptionsRequest = {}));
+export var PrivateDnsNameOptionsRequest;
+(function (PrivateDnsNameOptionsRequest) {
+    PrivateDnsNameOptionsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PrivateDnsNameOptionsRequest || (PrivateDnsNameOptionsRequest = {}));
+export var RunInstancesRequest;
+(function (RunInstancesRequest) {
+    RunInstancesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RunInstancesRequest || (RunInstancesRequest = {}));
+export var ScheduledInstancesEbs;
+(function (ScheduledInstancesEbs) {
+    ScheduledInstancesEbs.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ScheduledInstancesEbs || (ScheduledInstancesEbs = {}));
+export var ScheduledInstancesBlockDeviceMapping;
+(function (ScheduledInstancesBlockDeviceMapping) {
+    ScheduledInstancesBlockDeviceMapping.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ScheduledInstancesBlockDeviceMapping || (ScheduledInstancesBlockDeviceMapping = {}));
+export var ScheduledInstancesIamInstanceProfile;
+(function (ScheduledInstancesIamInstanceProfile) {
+    ScheduledInstancesIamInstanceProfile.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ScheduledInstancesIamInstanceProfile || (ScheduledInstancesIamInstanceProfile = {}));
+export var ScheduledInstancesMonitoring;
+(function (ScheduledInstancesMonitoring) {
+    ScheduledInstancesMonitoring.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ScheduledInstancesMonitoring || (ScheduledInstancesMonitoring = {}));
+export var ScheduledInstancesIpv6Address;
+(function (ScheduledInstancesIpv6Address) {
+    ScheduledInstancesIpv6Address.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ScheduledInstancesIpv6Address || (ScheduledInstancesIpv6Address = {}));
+export var ScheduledInstancesPrivateIpAddressConfig;
+(function (ScheduledInstancesPrivateIpAddressConfig) {
+    ScheduledInstancesPrivateIpAddressConfig.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ScheduledInstancesPrivateIpAddressConfig || (ScheduledInstancesPrivateIpAddressConfig = {}));
+export var ScheduledInstancesNetworkInterface;
+(function (ScheduledInstancesNetworkInterface) {
+    ScheduledInstancesNetworkInterface.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ScheduledInstancesNetworkInterface || (ScheduledInstancesNetworkInterface = {}));
+export var ScheduledInstancesPlacement;
+(function (ScheduledInstancesPlacement) {
+    ScheduledInstancesPlacement.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ScheduledInstancesPlacement || (ScheduledInstancesPlacement = {}));
+export var ScheduledInstancesLaunchSpecification;
+(function (ScheduledInstancesLaunchSpecification) {
+    ScheduledInstancesLaunchSpecification.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ScheduledInstancesLaunchSpecification || (ScheduledInstancesLaunchSpecification = {}));
+export var RunScheduledInstancesRequest;
+(function (RunScheduledInstancesRequest) {
+    RunScheduledInstancesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RunScheduledInstancesRequest || (RunScheduledInstancesRequest = {}));
+export var RunScheduledInstancesResult;
+(function (RunScheduledInstancesResult) {
+    RunScheduledInstancesResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RunScheduledInstancesResult || (RunScheduledInstancesResult = {}));
+export var SearchLocalGatewayRoutesRequest;
+(function (SearchLocalGatewayRoutesRequest) {
+    SearchLocalGatewayRoutesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(SearchLocalGatewayRoutesRequest || (SearchLocalGatewayRoutesRequest = {}));
+export var SearchLocalGatewayRoutesResult;
+(function (SearchLocalGatewayRoutesResult) {
+    SearchLocalGatewayRoutesResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(SearchLocalGatewayRoutesResult || (SearchLocalGatewayRoutesResult = {}));
+export var SearchTransitGatewayMulticastGroupsRequest;
+(function (SearchTransitGatewayMulticastGroupsRequest) {
+    SearchTransitGatewayMulticastGroupsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(SearchTransitGatewayMulticastGroupsRequest || (SearchTransitGatewayMulticastGroupsRequest = {}));
+export var TransitGatewayMulticastGroup;
+(function (TransitGatewayMulticastGroup) {
+    TransitGatewayMulticastGroup.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(TransitGatewayMulticastGroup || (TransitGatewayMulticastGroup = {}));
+export var SearchTransitGatewayMulticastGroupsResult;
+(function (SearchTransitGatewayMulticastGroupsResult) {
+    SearchTransitGatewayMulticastGroupsResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(SearchTransitGatewayMulticastGroupsResult || (SearchTransitGatewayMulticastGroupsResult = {}));
+export var SearchTransitGatewayRoutesRequest;
+(function (SearchTransitGatewayRoutesRequest) {
+    SearchTransitGatewayRoutesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(SearchTransitGatewayRoutesRequest || (SearchTransitGatewayRoutesRequest = {}));
+export var SearchTransitGatewayRoutesResult;
+(function (SearchTransitGatewayRoutesResult) {
+    SearchTransitGatewayRoutesResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(SearchTransitGatewayRoutesResult || (SearchTransitGatewayRoutesResult = {}));
+export var SendDiagnosticInterruptRequest;
+(function (SendDiagnosticInterruptRequest) {
+    SendDiagnosticInterruptRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(SendDiagnosticInterruptRequest || (SendDiagnosticInterruptRequest = {}));
+export var StartInstancesRequest;
+(function (StartInstancesRequest) {
+    StartInstancesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(StartInstancesRequest || (StartInstancesRequest = {}));
+export var InstanceStateChange;
+(function (InstanceStateChange) {
+    InstanceStateChange.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(InstanceStateChange || (InstanceStateChange = {}));
+export var StartInstancesResult;
+(function (StartInstancesResult) {
+    StartInstancesResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(StartInstancesResult || (StartInstancesResult = {}));
+export var StartNetworkInsightsAccessScopeAnalysisRequest;
+(function (StartNetworkInsightsAccessScopeAnalysisRequest) {
+    StartNetworkInsightsAccessScopeAnalysisRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(StartNetworkInsightsAccessScopeAnalysisRequest || (StartNetworkInsightsAccessScopeAnalysisRequest = {}));
+export var StartNetworkInsightsAccessScopeAnalysisResult;
+(function (StartNetworkInsightsAccessScopeAnalysisResult) {
+    StartNetworkInsightsAccessScopeAnalysisResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(StartNetworkInsightsAccessScopeAnalysisResult || (StartNetworkInsightsAccessScopeAnalysisResult = {}));
+export var StartNetworkInsightsAnalysisRequest;
+(function (StartNetworkInsightsAnalysisRequest) {
+    StartNetworkInsightsAnalysisRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(StartNetworkInsightsAnalysisRequest || (StartNetworkInsightsAnalysisRequest = {}));
+export var StartNetworkInsightsAnalysisResult;
+(function (StartNetworkInsightsAnalysisResult) {
+    StartNetworkInsightsAnalysisResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(StartNetworkInsightsAnalysisResult || (StartNetworkInsightsAnalysisResult = {}));
+export var StartVpcEndpointServicePrivateDnsVerificationRequest;
+(function (StartVpcEndpointServicePrivateDnsVerificationRequest) {
+    StartVpcEndpointServicePrivateDnsVerificationRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(StartVpcEndpointServicePrivateDnsVerificationRequest || (StartVpcEndpointServicePrivateDnsVerificationRequest = {}));
+export var StartVpcEndpointServicePrivateDnsVerificationResult;
+(function (StartVpcEndpointServicePrivateDnsVerificationResult) {
+    StartVpcEndpointServicePrivateDnsVerificationResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(StartVpcEndpointServicePrivateDnsVerificationResult || (StartVpcEndpointServicePrivateDnsVerificationResult = {}));
+export var StopInstancesRequest;
+(function (StopInstancesRequest) {
+    StopInstancesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(StopInstancesRequest || (StopInstancesRequest = {}));
+export var StopInstancesResult;
+(function (StopInstancesResult) {
+    StopInstancesResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(StopInstancesResult || (StopInstancesResult = {}));
+export var TerminateClientVpnConnectionsRequest;
+(function (TerminateClientVpnConnectionsRequest) {
+    TerminateClientVpnConnectionsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(TerminateClientVpnConnectionsRequest || (TerminateClientVpnConnectionsRequest = {}));
+export var TerminateConnectionStatus;
+(function (TerminateConnectionStatus) {
+    TerminateConnectionStatus.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(TerminateConnectionStatus || (TerminateConnectionStatus = {}));
+export var TerminateClientVpnConnectionsResult;
+(function (TerminateClientVpnConnectionsResult) {
+    TerminateClientVpnConnectionsResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(TerminateClientVpnConnectionsResult || (TerminateClientVpnConnectionsResult = {}));
+export var TerminateInstancesRequest;
+(function (TerminateInstancesRequest) {
+    TerminateInstancesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(TerminateInstancesRequest || (TerminateInstancesRequest = {}));
+export var TerminateInstancesResult;
+(function (TerminateInstancesResult) {
+    TerminateInstancesResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(TerminateInstancesResult || (TerminateInstancesResult = {}));
+export var UnassignIpv6AddressesRequest;
+(function (UnassignIpv6AddressesRequest) {
+    UnassignIpv6AddressesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UnassignIpv6AddressesRequest || (UnassignIpv6AddressesRequest = {}));
+export var UnassignIpv6AddressesResult;
+(function (UnassignIpv6AddressesResult) {
+    UnassignIpv6AddressesResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UnassignIpv6AddressesResult || (UnassignIpv6AddressesResult = {}));
+export var UnassignPrivateIpAddressesRequest;
+(function (UnassignPrivateIpAddressesRequest) {
+    UnassignPrivateIpAddressesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UnassignPrivateIpAddressesRequest || (UnassignPrivateIpAddressesRequest = {}));
+export var UnmonitorInstancesRequest;
+(function (UnmonitorInstancesRequest) {
+    UnmonitorInstancesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UnmonitorInstancesRequest || (UnmonitorInstancesRequest = {}));
+export var UnmonitorInstancesResult;
+(function (UnmonitorInstancesResult) {
+    UnmonitorInstancesResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UnmonitorInstancesResult || (UnmonitorInstancesResult = {}));
+export var SecurityGroupRuleDescription;
+(function (SecurityGroupRuleDescription) {
+    SecurityGroupRuleDescription.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(SecurityGroupRuleDescription || (SecurityGroupRuleDescription = {}));
+export var UpdateSecurityGroupRuleDescriptionsEgressRequest;
+(function (UpdateSecurityGroupRuleDescriptionsEgressRequest) {
+    UpdateSecurityGroupRuleDescriptionsEgressRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateSecurityGroupRuleDescriptionsEgressRequest || (UpdateSecurityGroupRuleDescriptionsEgressRequest = {}));
+export var UpdateSecurityGroupRuleDescriptionsEgressResult;
+(function (UpdateSecurityGroupRuleDescriptionsEgressResult) {
+    UpdateSecurityGroupRuleDescriptionsEgressResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateSecurityGroupRuleDescriptionsEgressResult || (UpdateSecurityGroupRuleDescriptionsEgressResult = {}));
+export var UpdateSecurityGroupRuleDescriptionsIngressRequest;
+(function (UpdateSecurityGroupRuleDescriptionsIngressRequest) {
+    UpdateSecurityGroupRuleDescriptionsIngressRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateSecurityGroupRuleDescriptionsIngressRequest || (UpdateSecurityGroupRuleDescriptionsIngressRequest = {}));
+export var UpdateSecurityGroupRuleDescriptionsIngressResult;
+(function (UpdateSecurityGroupRuleDescriptionsIngressResult) {
+    UpdateSecurityGroupRuleDescriptionsIngressResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateSecurityGroupRuleDescriptionsIngressResult || (UpdateSecurityGroupRuleDescriptionsIngressResult = {}));
+export var WithdrawByoipCidrRequest;
+(function (WithdrawByoipCidrRequest) {
+    WithdrawByoipCidrRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(WithdrawByoipCidrRequest || (WithdrawByoipCidrRequest = {}));
+export var WithdrawByoipCidrResult;
+(function (WithdrawByoipCidrResult) {
+    WithdrawByoipCidrResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(WithdrawByoipCidrResult || (WithdrawByoipCidrResult = {}));

package/dist-es/pagination/DescribeIpamPoolsPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { DescribeIpamPoolsCommand, } from "../commands/DescribeIpamPoolsCommand";
+import { EC2 } from "../EC2";
+import { EC2Client } from "../EC2Client";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new DescribeIpamPoolsCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.describeIpamPools.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateDescribeIpamPools(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateDescribeIpamPools_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.NextToken = token;
+                    input["MaxResults"] = config.pageSize;
+                    if (!(config.client instanceof EC2)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof EC2Client)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected EC2 | EC2Client");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.NextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/DescribeIpamScopesPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { DescribeIpamScopesCommand, } from "../commands/DescribeIpamScopesCommand";
+import { EC2 } from "../EC2";
+import { EC2Client } from "../EC2Client";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new DescribeIpamScopesCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.describeIpamScopes.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateDescribeIpamScopes(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateDescribeIpamScopes_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.NextToken = token;
+                    input["MaxResults"] = config.pageSize;
+                    if (!(config.client instanceof EC2)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof EC2Client)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected EC2 | EC2Client");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.NextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/DescribeIpamsPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { DescribeIpamsCommand, } from "../commands/DescribeIpamsCommand";
+import { EC2 } from "../EC2";
+import { EC2Client } from "../EC2Client";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new DescribeIpamsCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.describeIpams.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateDescribeIpams(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateDescribeIpams_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.NextToken = token;
+                    input["MaxResults"] = config.pageSize;
+                    if (!(config.client instanceof EC2)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof EC2Client)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected EC2 | EC2Client");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.NextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/DescribeNetworkInsightsAccessScopeAnalysesPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { DescribeNetworkInsightsAccessScopeAnalysesCommand, } from "../commands/DescribeNetworkInsightsAccessScopeAnalysesCommand";
+import { EC2 } from "../EC2";
+import { EC2Client } from "../EC2Client";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new DescribeNetworkInsightsAccessScopeAnalysesCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.describeNetworkInsightsAccessScopeAnalyses.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateDescribeNetworkInsightsAccessScopeAnalyses(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateDescribeNetworkInsightsAccessScopeAnalyses_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.NextToken = token;
+                    input["MaxResults"] = config.pageSize;
+                    if (!(config.client instanceof EC2)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof EC2Client)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected EC2 | EC2Client");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.NextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/DescribeNetworkInsightsAccessScopesPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { DescribeNetworkInsightsAccessScopesCommand, } from "../commands/DescribeNetworkInsightsAccessScopesCommand";
+import { EC2 } from "../EC2";
+import { EC2Client } from "../EC2Client";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new DescribeNetworkInsightsAccessScopesCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.describeNetworkInsightsAccessScopes.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateDescribeNetworkInsightsAccessScopes(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateDescribeNetworkInsightsAccessScopes_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.NextToken = token;
+                    input["MaxResults"] = config.pageSize;
+                    if (!(config.client instanceof EC2)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof EC2Client)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected EC2 | EC2Client");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.NextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/DescribeSnapshotTierStatusPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { DescribeSnapshotTierStatusCommand, } from "../commands/DescribeSnapshotTierStatusCommand";
+import { EC2 } from "../EC2";
+import { EC2Client } from "../EC2Client";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new DescribeSnapshotTierStatusCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.describeSnapshotTierStatus.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateDescribeSnapshotTierStatus(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateDescribeSnapshotTierStatus_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.NextToken = token;
+                    input["MaxResults"] = config.pageSize;
+                    if (!(config.client instanceof EC2)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof EC2Client)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected EC2 | EC2Client");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.NextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}