@aws-sdk/client-device-farm 3.34.0 → 3.37.0

package/dist-cjs/pagination/GetOfferingStatusPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateGetOfferingStatus = void 0;
+const GetOfferingStatusCommand_1 = require("../commands/GetOfferingStatusCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetOfferingStatusCommand_1.GetOfferingStatusCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.getOfferingStatus(input, ...args);
+};
+async function* paginateGetOfferingStatus(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateGetOfferingStatus = paginateGetOfferingStatus;

package/dist-cjs/pagination/Interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/pagination/ListArtifactsPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListArtifacts = void 0;
+const ListArtifactsCommand_1 = require("../commands/ListArtifactsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListArtifactsCommand_1.ListArtifactsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listArtifacts(input, ...args);
+};
+async function* paginateListArtifacts(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListArtifacts = paginateListArtifacts;

package/dist-cjs/pagination/ListDevicePoolsPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListDevicePools = void 0;
+const ListDevicePoolsCommand_1 = require("../commands/ListDevicePoolsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDevicePoolsCommand_1.ListDevicePoolsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listDevicePools(input, ...args);
+};
+async function* paginateListDevicePools(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListDevicePools = paginateListDevicePools;

package/dist-cjs/pagination/ListDevicesPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListDevices = void 0;
+const ListDevicesCommand_1 = require("../commands/ListDevicesCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDevicesCommand_1.ListDevicesCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listDevices(input, ...args);
+};
+async function* paginateListDevices(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListDevices = paginateListDevices;

package/dist-cjs/pagination/ListJobsPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListJobs = void 0;
+const ListJobsCommand_1 = require("../commands/ListJobsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListJobsCommand_1.ListJobsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listJobs(input, ...args);
+};
+async function* paginateListJobs(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListJobs = paginateListJobs;

package/dist-cjs/pagination/ListOfferingTransactionsPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListOfferingTransactions = void 0;
+const ListOfferingTransactionsCommand_1 = require("../commands/ListOfferingTransactionsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListOfferingTransactionsCommand_1.ListOfferingTransactionsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listOfferingTransactions(input, ...args);
+};
+async function* paginateListOfferingTransactions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListOfferingTransactions = paginateListOfferingTransactions;

package/dist-cjs/pagination/ListOfferingsPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListOfferings = void 0;
+const ListOfferingsCommand_1 = require("../commands/ListOfferingsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListOfferingsCommand_1.ListOfferingsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listOfferings(input, ...args);
+};
+async function* paginateListOfferings(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListOfferings = paginateListOfferings;

package/dist-cjs/pagination/ListProjectsPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListProjects = void 0;
+const ListProjectsCommand_1 = require("../commands/ListProjectsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListProjectsCommand_1.ListProjectsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listProjects(input, ...args);
+};
+async function* paginateListProjects(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListProjects = paginateListProjects;

package/dist-cjs/pagination/ListRunsPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListRuns = void 0;
+const ListRunsCommand_1 = require("../commands/ListRunsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListRunsCommand_1.ListRunsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listRuns(input, ...args);
+};
+async function* paginateListRuns(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListRuns = paginateListRuns;

package/dist-cjs/pagination/ListSamplesPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListSamples = void 0;
+const ListSamplesCommand_1 = require("../commands/ListSamplesCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListSamplesCommand_1.ListSamplesCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listSamples(input, ...args);
+};
+async function* paginateListSamples(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListSamples = paginateListSamples;

package/dist-cjs/pagination/ListSuitesPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListSuites = void 0;
+const ListSuitesCommand_1 = require("../commands/ListSuitesCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListSuitesCommand_1.ListSuitesCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listSuites(input, ...args);
+};
+async function* paginateListSuites(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListSuites = paginateListSuites;

package/dist-cjs/pagination/ListTestGridProjectsPaginator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListTestGridProjects = void 0;
+const ListTestGridProjectsCommand_1 = require("../commands/ListTestGridProjectsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListTestGridProjectsCommand_1.ListTestGridProjectsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listTestGridProjects(input, ...args);
+};
+async function* paginateListTestGridProjects(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResult"] = config.pageSize;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListTestGridProjects = paginateListTestGridProjects;

package/dist-cjs/pagination/ListTestGridSessionActionsPaginator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListTestGridSessionActions = void 0;
+const ListTestGridSessionActionsCommand_1 = require("../commands/ListTestGridSessionActionsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListTestGridSessionActionsCommand_1.ListTestGridSessionActionsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listTestGridSessionActions(input, ...args);
+};
+async function* paginateListTestGridSessionActions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResult"] = config.pageSize;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListTestGridSessionActions = paginateListTestGridSessionActions;

package/dist-cjs/pagination/ListTestGridSessionArtifactsPaginator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListTestGridSessionArtifacts = void 0;
+const ListTestGridSessionArtifactsCommand_1 = require("../commands/ListTestGridSessionArtifactsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListTestGridSessionArtifactsCommand_1.ListTestGridSessionArtifactsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listTestGridSessionArtifacts(input, ...args);
+};
+async function* paginateListTestGridSessionArtifacts(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResult"] = config.pageSize;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListTestGridSessionArtifacts = paginateListTestGridSessionArtifacts;

package/dist-cjs/pagination/ListTestGridSessionsPaginator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListTestGridSessions = void 0;
+const ListTestGridSessionsCommand_1 = require("../commands/ListTestGridSessionsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListTestGridSessionsCommand_1.ListTestGridSessionsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listTestGridSessions(input, ...args);
+};
+async function* paginateListTestGridSessions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResult"] = config.pageSize;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListTestGridSessions = paginateListTestGridSessions;

package/dist-cjs/pagination/ListTestsPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListTests = void 0;
+const ListTestsCommand_1 = require("../commands/ListTestsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListTestsCommand_1.ListTestsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listTests(input, ...args);
+};
+async function* paginateListTests(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListTests = paginateListTests;

package/dist-cjs/pagination/ListUniqueProblemsPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListUniqueProblems = void 0;
+const ListUniqueProblemsCommand_1 = require("../commands/ListUniqueProblemsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListUniqueProblemsCommand_1.ListUniqueProblemsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listUniqueProblems(input, ...args);
+};
+async function* paginateListUniqueProblems(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListUniqueProblems = paginateListUniqueProblems;

package/dist-cjs/pagination/ListUploadsPaginator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListUploads = void 0;
+const ListUploadsCommand_1 = require("../commands/ListUploadsCommand");
+const DeviceFarm_1 = require("../DeviceFarm");
+const DeviceFarmClient_1 = require("../DeviceFarmClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListUploadsCommand_1.ListUploadsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listUploads(input, ...args);
+};
+async function* paginateListUploads(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof DeviceFarm_1.DeviceFarm) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof DeviceFarmClient_1.DeviceFarmClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DeviceFarm | DeviceFarmClient");
+        }
+        yield page;
+        token = page.nextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListUploads = paginateListUploads;