@aws-sdk/client-iam 3.183.0 → 3.186.0

package/dist-es/models/models_1.js

@@ -1,160 +1,103 @@
+import { __assign, __extends } from "tslib";
 import { SENSITIVE_STRING } from "@aws-sdk/smithy-client";
 import { IAMServiceException as __BaseException } from "./IAMServiceException";
-export class KeyPairMismatchException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "KeyPairMismatchException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "KeyPairMismatchException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, KeyPairMismatchException.prototype);
+var KeyPairMismatchException = (function (_super) {
+    __extends(KeyPairMismatchException, _super);
+    function KeyPairMismatchException(opts) {
+        var _this = _super.call(this, __assign({ name: "KeyPairMismatchException", $fault: "client" }, opts)) || this;
+        _this.name = "KeyPairMismatchException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, KeyPairMismatchException.prototype);
+        return _this;
     }
-}
-export class MalformedCertificateException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "MalformedCertificateException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "MalformedCertificateException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, MalformedCertificateException.prototype);
+    return KeyPairMismatchException;
+}(__BaseException));
+export { KeyPairMismatchException };
+var MalformedCertificateException = (function (_super) {
+    __extends(MalformedCertificateException, _super);
+    function MalformedCertificateException(opts) {
+        var _this = _super.call(this, __assign({ name: "MalformedCertificateException", $fault: "client" }, opts)) || this;
+        _this.name = "MalformedCertificateException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, MalformedCertificateException.prototype);
+        return _this;
     }
-}
-export class DuplicateCertificateException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "DuplicateCertificateException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "DuplicateCertificateException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, DuplicateCertificateException.prototype);
+    return MalformedCertificateException;
+}(__BaseException));
+export { MalformedCertificateException };
+var DuplicateCertificateException = (function (_super) {
+    __extends(DuplicateCertificateException, _super);
+    function DuplicateCertificateException(opts) {
+        var _this = _super.call(this, __assign({ name: "DuplicateCertificateException", $fault: "client" }, opts)) || this;
+        _this.name = "DuplicateCertificateException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, DuplicateCertificateException.prototype);
+        return _this;
     }
-}
-export class InvalidCertificateException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "InvalidCertificateException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "InvalidCertificateException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, InvalidCertificateException.prototype);
+    return DuplicateCertificateException;
+}(__BaseException));
+export { DuplicateCertificateException };
+var InvalidCertificateException = (function (_super) {
+    __extends(InvalidCertificateException, _super);
+    function InvalidCertificateException(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidCertificateException", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidCertificateException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidCertificateException.prototype);
+        return _this;
     }
-}
-export class DuplicateSSHPublicKeyException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "DuplicateSSHPublicKeyException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "DuplicateSSHPublicKeyException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, DuplicateSSHPublicKeyException.prototype);
+    return InvalidCertificateException;
+}(__BaseException));
+export { InvalidCertificateException };
+var DuplicateSSHPublicKeyException = (function (_super) {
+    __extends(DuplicateSSHPublicKeyException, _super);
+    function DuplicateSSHPublicKeyException(opts) {
+        var _this = _super.call(this, __assign({ name: "DuplicateSSHPublicKeyException", $fault: "client" }, opts)) || this;
+        _this.name = "DuplicateSSHPublicKeyException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, DuplicateSSHPublicKeyException.prototype);
+        return _this;
     }
-}
-export class InvalidPublicKeyException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "InvalidPublicKeyException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "InvalidPublicKeyException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, InvalidPublicKeyException.prototype);
+    return DuplicateSSHPublicKeyException;
+}(__BaseException));
+export { DuplicateSSHPublicKeyException };
+var InvalidPublicKeyException = (function (_super) {
+    __extends(InvalidPublicKeyException, _super);
+    function InvalidPublicKeyException(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidPublicKeyException", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidPublicKeyException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidPublicKeyException.prototype);
+        return _this;
     }
-}
-export const UntagPolicyRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UntagRoleRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UntagSAMLProviderRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UntagServerCertificateRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UntagUserRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateAccessKeyRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateAccountPasswordPolicyRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateAssumeRolePolicyRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateGroupRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateLoginProfileRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Password && { Password: SENSITIVE_STRING }),
-});
-export const UpdateOpenIDConnectProviderThumbprintRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateRoleRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateRoleResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateRoleDescriptionRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateRoleDescriptionResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateSAMLProviderRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateSAMLProviderResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateServerCertificateRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateServiceSpecificCredentialRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateSigningCertificateRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateSSHPublicKeyRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UpdateUserRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UploadServerCertificateRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PrivateKey && { PrivateKey: SENSITIVE_STRING }),
-});
-export const UploadServerCertificateResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UploadSigningCertificateRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UploadSigningCertificateResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UploadSSHPublicKeyRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-export const UploadSSHPublicKeyResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
+    return InvalidPublicKeyException;
+}(__BaseException));
+export { InvalidPublicKeyException };
+export var UntagPolicyRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UntagRoleRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UntagSAMLProviderRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UntagServerCertificateRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UntagUserRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateAccessKeyRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateAccountPasswordPolicyRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateAssumeRolePolicyRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateGroupRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateLoginProfileRequestFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.Password && { Password: SENSITIVE_STRING }))); };
+export var UpdateOpenIDConnectProviderThumbprintRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateRoleRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateRoleResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateRoleDescriptionRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateRoleDescriptionResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateSAMLProviderRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateSAMLProviderResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateServerCertificateRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateServiceSpecificCredentialRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateSigningCertificateRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateSSHPublicKeyRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UpdateUserRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UploadServerCertificateRequestFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.PrivateKey && { PrivateKey: SENSITIVE_STRING }))); };
+export var UploadServerCertificateResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UploadSigningCertificateRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UploadSigningCertificateResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UploadSSHPublicKeyRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var UploadSSHPublicKeyResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };

package/dist-es/pagination/GetAccountAuthorizationDetailsPaginator.js

@@ -1,32 +1,75 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { GetAccountAuthorizationDetailsCommand, } from "../commands/GetAccountAuthorizationDetailsCommand";
 import { IAM } from "../IAM";
 import { IAMClient } from "../IAMClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new GetAccountAuthorizationDetailsCommand(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 GetAccountAuthorizationDetailsCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.getAccountAuthorizationDetails(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.getAccountAuthorizationDetails.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
 };
-export async function* paginateGetAccountAuthorizationDetails(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.Marker = token;
-        input["MaxItems"] = config.pageSize;
-        if (config.client instanceof IAM) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IAMClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected IAM | IAMClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.Marker;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+export function paginateGetAccountAuthorizationDetails(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
     }
-    return undefined;
+    return __asyncGenerator(this, arguments, function paginateGetAccountAuthorizationDetails_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.Marker = token;
+                    input["MaxItems"] = config.pageSize;
+                    if (!(config.client instanceof IAM)) 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 IAMClient)) 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 IAM | IAMClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    prevToken = token;
+                    token = page.Marker;
+                    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/GetGroupPaginator.js

@@ -1,32 +1,75 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { GetGroupCommand } from "../commands/GetGroupCommand";
 import { IAM } from "../IAM";
 import { IAMClient } from "../IAMClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new GetGroupCommand(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 GetGroupCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.getGroup(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.getGroup.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
 };
-export async function* paginateGetGroup(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.Marker = token;
-        input["MaxItems"] = config.pageSize;
-        if (config.client instanceof IAM) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IAMClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected IAM | IAMClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.Marker;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+export function paginateGetGroup(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
     }
-    return undefined;
+    return __asyncGenerator(this, arguments, function paginateGetGroup_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.Marker = token;
+                    input["MaxItems"] = config.pageSize;
+                    if (!(config.client instanceof IAM)) 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 IAMClient)) 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 IAM | IAMClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    prevToken = token;
+                    token = page.Marker;
+                    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/ListAccessKeysPaginator.js

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