@aws-sdk/client-connect 3.180.0 → 3.183.0

package/dist-es/pagination/ListUserHierarchyGroupsPaginator.js

@@ -1,75 +1,32 @@
-import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { ListUserHierarchyGroupsCommand, } from "../commands/ListUserHierarchyGroupsCommand";
 import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
-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 ListUserHierarchyGroupsCommand(input)], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListUserHierarchyGroupsCommand(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.listUserHierarchyGroups.apply(client, __spreadArray([input], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listUserHierarchyGroups(input, ...args);
 };
-export function paginateListUserHierarchyGroups(config, input) {
-    var additionalArguments = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        additionalArguments[_i - 2] = arguments[_i];
+export async function* paginateListUserHierarchyGroups(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 Connect) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ConnectClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Connect | ConnectClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
     }
-    return __asyncGenerator(this, arguments, function paginateListUserHierarchyGroups_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 Connect)) 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 ConnectClient)) 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 Connect | ConnectClient");
-                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()];
-            }
-        });
-    });
+    return undefined;
 }

package/dist-es/pagination/ListUsersPaginator.js

@@ -1,75 +1,32 @@
-import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { ListUsersCommand } from "../commands/ListUsersCommand";
 import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
-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 ListUsersCommand(input)], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListUsersCommand(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.listUsers.apply(client, __spreadArray([input], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listUsers(input, ...args);
 };
-export function paginateListUsers(config, input) {
-    var additionalArguments = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        additionalArguments[_i - 2] = arguments[_i];
+export async function* paginateListUsers(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 Connect) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ConnectClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Connect | ConnectClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
     }
-    return __asyncGenerator(this, arguments, function paginateListUsers_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 Connect)) 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 ConnectClient)) 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 Connect | ConnectClient");
-                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()];
-            }
-        });
-    });
+    return undefined;
 }

package/dist-es/pagination/SearchAvailablePhoneNumbersPaginator.js

@@ -1,75 +1,32 @@
-import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { SearchAvailablePhoneNumbersCommand, } from "../commands/SearchAvailablePhoneNumbersCommand";
 import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
-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 SearchAvailablePhoneNumbersCommand(input)], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new SearchAvailablePhoneNumbersCommand(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.searchAvailablePhoneNumbers.apply(client, __spreadArray([input], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.searchAvailablePhoneNumbers(input, ...args);
 };
-export function paginateSearchAvailablePhoneNumbers(config, input) {
-    var additionalArguments = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        additionalArguments[_i - 2] = arguments[_i];
+export async function* paginateSearchAvailablePhoneNumbers(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 Connect) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ConnectClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Connect | ConnectClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
     }
-    return __asyncGenerator(this, arguments, function paginateSearchAvailablePhoneNumbers_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 Connect)) 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 ConnectClient)) 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 Connect | ConnectClient");
-                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()];
-            }
-        });
-    });
+    return undefined;
 }

package/dist-es/pagination/SearchQueuesPaginator.js

@@ -1,75 +1,32 @@
-import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { SearchQueuesCommand, } from "../commands/SearchQueuesCommand";
 import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
-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 SearchQueuesCommand(input)], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new SearchQueuesCommand(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.searchQueues.apply(client, __spreadArray([input], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.searchQueues(input, ...args);
 };
-export function paginateSearchQueues(config, input) {
-    var additionalArguments = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        additionalArguments[_i - 2] = arguments[_i];
+export async function* paginateSearchQueues(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 Connect) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ConnectClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Connect | ConnectClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
     }
-    return __asyncGenerator(this, arguments, function paginateSearchQueues_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 Connect)) 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 ConnectClient)) 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 Connect | ConnectClient");
-                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()];
-            }
-        });
-    });
+    return undefined;
 }

package/dist-es/pagination/SearchRoutingProfilesPaginator.js

@@ -1,75 +1,32 @@
-import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { SearchRoutingProfilesCommand, } from "../commands/SearchRoutingProfilesCommand";
 import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
-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 SearchRoutingProfilesCommand(input)], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new SearchRoutingProfilesCommand(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.searchRoutingProfiles.apply(client, __spreadArray([input], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.searchRoutingProfiles(input, ...args);
 };
-export function paginateSearchRoutingProfiles(config, input) {
-    var additionalArguments = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        additionalArguments[_i - 2] = arguments[_i];
+export async function* paginateSearchRoutingProfiles(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 Connect) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ConnectClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Connect | ConnectClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
     }
-    return __asyncGenerator(this, arguments, function paginateSearchRoutingProfiles_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 Connect)) 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 ConnectClient)) 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 Connect | ConnectClient");
-                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()];
-            }
-        });
-    });
+    return undefined;
 }

package/dist-es/pagination/SearchSecurityProfilesPaginator.js

@@ -1,75 +1,32 @@
-import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { SearchSecurityProfilesCommand, } from "../commands/SearchSecurityProfilesCommand";
 import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
-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 SearchSecurityProfilesCommand(input)], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new SearchSecurityProfilesCommand(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.searchSecurityProfiles.apply(client, __spreadArray([input], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.searchSecurityProfiles(input, ...args);
 };
-export function paginateSearchSecurityProfiles(config, input) {
-    var additionalArguments = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        additionalArguments[_i - 2] = arguments[_i];
+export async function* paginateSearchSecurityProfiles(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 Connect) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ConnectClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Connect | ConnectClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
     }
-    return __asyncGenerator(this, arguments, function paginateSearchSecurityProfiles_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 Connect)) 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 ConnectClient)) 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 Connect | ConnectClient");
-                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()];
-            }
-        });
-    });
+    return undefined;
 }