@aws-sdk/client-support 3.183.0 → 3.186.0

package/dist-es/endpoints.js

@@ -1,5 +1,6 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { getRegionInfo } from "@aws-sdk/config-resolver";
-const regionHash = {
+var regionHash = {
     "aws-cn-global": {
         variants: [
             {
@@ -46,7 +47,7 @@ const regionHash = {
         signingRegion: "us-gov-west-1",
     },
 };
-const partitionHash = {
+var partitionHash = {
     aws: {
         regions: [
             "af-south-1",
@@ -167,9 +168,8 @@ const partitionHash = {
         ],
     },
 };
-export const defaultRegionInfoProvider = async (region, options) => getRegionInfo(region, {
-    ...options,
-    signingService: "support",
-    regionHash,
-    partitionHash,
-});
+export var defaultRegionInfoProvider = function (region, options) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2, getRegionInfo(region, __assign(__assign({}, options), { signingService: "support", regionHash: regionHash, partitionHash: partitionHash }))];
+    });
+}); };

package/dist-es/models/SupportServiceException.js

@@ -1,7 +1,12 @@
+import { __extends } from "tslib";
 import { ServiceException as __ServiceException, } from "@aws-sdk/smithy-client";
-export class SupportServiceException extends __ServiceException {
-    constructor(options) {
-        super(options);
-        Object.setPrototypeOf(this, SupportServiceException.prototype);
+var SupportServiceException = (function (_super) {
+    __extends(SupportServiceException, _super);
+    function SupportServiceException(options) {
+        var _this = _super.call(this, options) || this;
+        Object.setPrototypeOf(_this, SupportServiceException.prototype);
+        return _this;
     }
-}
+    return SupportServiceException;
+}(__ServiceException));
+export { SupportServiceException };

package/dist-es/models/models_0.js

@@ -1,241 +1,154 @@
+import { __assign, __extends } from "tslib";
 import { SupportServiceException as __BaseException } from "./SupportServiceException";
-export class AttachmentLimitExceeded extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "AttachmentLimitExceeded",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "AttachmentLimitExceeded";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, AttachmentLimitExceeded.prototype);
+var AttachmentLimitExceeded = (function (_super) {
+    __extends(AttachmentLimitExceeded, _super);
+    function AttachmentLimitExceeded(opts) {
+        var _this = _super.call(this, __assign({ name: "AttachmentLimitExceeded", $fault: "client" }, opts)) || this;
+        _this.name = "AttachmentLimitExceeded";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, AttachmentLimitExceeded.prototype);
+        return _this;
     }
-}
-export class AttachmentSetExpired extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "AttachmentSetExpired",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "AttachmentSetExpired";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, AttachmentSetExpired.prototype);
+    return AttachmentLimitExceeded;
+}(__BaseException));
+export { AttachmentLimitExceeded };
+var AttachmentSetExpired = (function (_super) {
+    __extends(AttachmentSetExpired, _super);
+    function AttachmentSetExpired(opts) {
+        var _this = _super.call(this, __assign({ name: "AttachmentSetExpired", $fault: "client" }, opts)) || this;
+        _this.name = "AttachmentSetExpired";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, AttachmentSetExpired.prototype);
+        return _this;
     }
-}
-export class AttachmentSetIdNotFound extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "AttachmentSetIdNotFound",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "AttachmentSetIdNotFound";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, AttachmentSetIdNotFound.prototype);
+    return AttachmentSetExpired;
+}(__BaseException));
+export { AttachmentSetExpired };
+var AttachmentSetIdNotFound = (function (_super) {
+    __extends(AttachmentSetIdNotFound, _super);
+    function AttachmentSetIdNotFound(opts) {
+        var _this = _super.call(this, __assign({ name: "AttachmentSetIdNotFound", $fault: "client" }, opts)) || this;
+        _this.name = "AttachmentSetIdNotFound";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, AttachmentSetIdNotFound.prototype);
+        return _this;
     }
-}
-export class AttachmentSetSizeLimitExceeded extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "AttachmentSetSizeLimitExceeded",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "AttachmentSetSizeLimitExceeded";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, AttachmentSetSizeLimitExceeded.prototype);
+    return AttachmentSetIdNotFound;
+}(__BaseException));
+export { AttachmentSetIdNotFound };
+var AttachmentSetSizeLimitExceeded = (function (_super) {
+    __extends(AttachmentSetSizeLimitExceeded, _super);
+    function AttachmentSetSizeLimitExceeded(opts) {
+        var _this = _super.call(this, __assign({ name: "AttachmentSetSizeLimitExceeded", $fault: "client" }, opts)) || this;
+        _this.name = "AttachmentSetSizeLimitExceeded";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, AttachmentSetSizeLimitExceeded.prototype);
+        return _this;
     }
-}
-export class InternalServerError extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "InternalServerError",
-            $fault: "server",
-            ...opts,
-        });
-        this.name = "InternalServerError";
-        this.$fault = "server";
-        Object.setPrototypeOf(this, InternalServerError.prototype);
+    return AttachmentSetSizeLimitExceeded;
+}(__BaseException));
+export { AttachmentSetSizeLimitExceeded };
+var InternalServerError = (function (_super) {
+    __extends(InternalServerError, _super);
+    function InternalServerError(opts) {
+        var _this = _super.call(this, __assign({ name: "InternalServerError", $fault: "server" }, opts)) || this;
+        _this.name = "InternalServerError";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, InternalServerError.prototype);
+        return _this;
     }
-}
-export class CaseIdNotFound extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "CaseIdNotFound",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "CaseIdNotFound";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, CaseIdNotFound.prototype);
+    return InternalServerError;
+}(__BaseException));
+export { InternalServerError };
+var CaseIdNotFound = (function (_super) {
+    __extends(CaseIdNotFound, _super);
+    function CaseIdNotFound(opts) {
+        var _this = _super.call(this, __assign({ name: "CaseIdNotFound", $fault: "client" }, opts)) || this;
+        _this.name = "CaseIdNotFound";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, CaseIdNotFound.prototype);
+        return _this;
     }
-}
-export class AttachmentIdNotFound extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "AttachmentIdNotFound",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "AttachmentIdNotFound";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, AttachmentIdNotFound.prototype);
+    return CaseIdNotFound;
+}(__BaseException));
+export { CaseIdNotFound };
+var AttachmentIdNotFound = (function (_super) {
+    __extends(AttachmentIdNotFound, _super);
+    function AttachmentIdNotFound(opts) {
+        var _this = _super.call(this, __assign({ name: "AttachmentIdNotFound", $fault: "client" }, opts)) || this;
+        _this.name = "AttachmentIdNotFound";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, AttachmentIdNotFound.prototype);
+        return _this;
     }
-}
-export class CaseCreationLimitExceeded extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "CaseCreationLimitExceeded",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "CaseCreationLimitExceeded";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, CaseCreationLimitExceeded.prototype);
+    return AttachmentIdNotFound;
+}(__BaseException));
+export { AttachmentIdNotFound };
+var CaseCreationLimitExceeded = (function (_super) {
+    __extends(CaseCreationLimitExceeded, _super);
+    function CaseCreationLimitExceeded(opts) {
+        var _this = _super.call(this, __assign({ name: "CaseCreationLimitExceeded", $fault: "client" }, opts)) || this;
+        _this.name = "CaseCreationLimitExceeded";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, CaseCreationLimitExceeded.prototype);
+        return _this;
     }
-}
-export class DescribeAttachmentLimitExceeded extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "DescribeAttachmentLimitExceeded",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "DescribeAttachmentLimitExceeded";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, DescribeAttachmentLimitExceeded.prototype);
+    return CaseCreationLimitExceeded;
+}(__BaseException));
+export { CaseCreationLimitExceeded };
+var DescribeAttachmentLimitExceeded = (function (_super) {
+    __extends(DescribeAttachmentLimitExceeded, _super);
+    function DescribeAttachmentLimitExceeded(opts) {
+        var _this = _super.call(this, __assign({ name: "DescribeAttachmentLimitExceeded", $fault: "client" }, opts)) || this;
+        _this.name = "DescribeAttachmentLimitExceeded";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, DescribeAttachmentLimitExceeded.prototype);
+        return _this;
     }
-}
-export const AttachmentFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const AddAttachmentsToSetRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const AddAttachmentsToSetResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const AddCommunicationToCaseRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const AddCommunicationToCaseResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const AttachmentDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const CreateCaseRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const CreateCaseResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeAttachmentRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeAttachmentResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeCasesRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const CommunicationFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const RecentCaseCommunicationsFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const CaseDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeCasesResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeCommunicationsRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeCommunicationsResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeServicesRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const CategoryFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const ServiceFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeServicesResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeSeverityLevelsRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const SeverityLevelFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeSeverityLevelsResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeTrustedAdvisorCheckRefreshStatusesRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const TrustedAdvisorCheckRefreshStatusFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeTrustedAdvisorCheckRefreshStatusesResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeTrustedAdvisorCheckResultRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const TrustedAdvisorCostOptimizingSummaryFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const TrustedAdvisorCategorySpecificSummaryFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const TrustedAdvisorResourceDetailFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const TrustedAdvisorResourcesSummaryFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const TrustedAdvisorCheckResultFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeTrustedAdvisorCheckResultResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeTrustedAdvisorChecksRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const TrustedAdvisorCheckDescriptionFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeTrustedAdvisorChecksResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeTrustedAdvisorCheckSummariesRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const TrustedAdvisorCheckSummaryFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const DescribeTrustedAdvisorCheckSummariesResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const RefreshTrustedAdvisorCheckRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const RefreshTrustedAdvisorCheckResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const ResolveCaseRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const ResolveCaseResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
+    return DescribeAttachmentLimitExceeded;
+}(__BaseException));
+export { DescribeAttachmentLimitExceeded };
+export var AttachmentFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var AddAttachmentsToSetRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var AddAttachmentsToSetResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var AddCommunicationToCaseRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var AddCommunicationToCaseResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var AttachmentDetailsFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var CreateCaseRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var CreateCaseResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeAttachmentRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeAttachmentResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeCasesRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var CommunicationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var RecentCaseCommunicationsFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var CaseDetailsFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeCasesResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeCommunicationsRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeCommunicationsResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeServicesRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var CategoryFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var ServiceFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeServicesResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeSeverityLevelsRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var SeverityLevelFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeSeverityLevelsResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeTrustedAdvisorCheckRefreshStatusesRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var TrustedAdvisorCheckRefreshStatusFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeTrustedAdvisorCheckRefreshStatusesResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeTrustedAdvisorCheckResultRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var TrustedAdvisorCostOptimizingSummaryFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var TrustedAdvisorCategorySpecificSummaryFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var TrustedAdvisorResourceDetailFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var TrustedAdvisorResourcesSummaryFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var TrustedAdvisorCheckResultFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeTrustedAdvisorCheckResultResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeTrustedAdvisorChecksRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var TrustedAdvisorCheckDescriptionFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeTrustedAdvisorChecksResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeTrustedAdvisorCheckSummariesRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var TrustedAdvisorCheckSummaryFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DescribeTrustedAdvisorCheckSummariesResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var RefreshTrustedAdvisorCheckRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var RefreshTrustedAdvisorCheckResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var ResolveCaseRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var ResolveCaseResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };

package/dist-es/pagination/DescribeCasesPaginator.js

@@ -1,32 +1,75 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { DescribeCasesCommand, } from "../commands/DescribeCasesCommand";
 import { Support } from "../Support";
 import { SupportClient } from "../SupportClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new DescribeCasesCommand(input), ...args);
+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 DescribeCasesCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeCases(input, ...args);
+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.describeCases.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
 };
-export async function* paginateDescribeCases(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.nextToken = token;
-        input["maxResults"] = config.pageSize;
-        if (config.client instanceof Support) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof SupportClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Support | SupportClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.nextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+export function paginateDescribeCases(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
     }
-    return undefined;
+    return __asyncGenerator(this, arguments, function paginateDescribeCases_1() {
+        var token, hasNext, page, prevToken;
+        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 Support)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof SupportClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected Support | SupportClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    prevToken = token;
+                    token = page.nextToken;
+                    hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
 }

package/dist-es/pagination/DescribeCommunicationsPaginator.js

@@ -1,32 +1,75 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { DescribeCommunicationsCommand, } from "../commands/DescribeCommunicationsCommand";
 import { Support } from "../Support";
 import { SupportClient } from "../SupportClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new DescribeCommunicationsCommand(input), ...args);
+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 DescribeCommunicationsCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeCommunications(input, ...args);
+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.describeCommunications.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
 };
-export async function* paginateDescribeCommunications(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.nextToken = token;
-        input["maxResults"] = config.pageSize;
-        if (config.client instanceof Support) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof SupportClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Support | SupportClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.nextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+export function paginateDescribeCommunications(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
     }
-    return undefined;
+    return __asyncGenerator(this, arguments, function paginateDescribeCommunications_1() {
+        var token, hasNext, page, prevToken;
+        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 Support)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof SupportClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected Support | SupportClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    prevToken = token;
+                    token = page.nextToken;
+                    hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
 }