@aws-sdk/client-wellarchitected 3.476.0 → 3.478.0

package/dist-es/pagination/GetConsolidatedReportPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { GetConsolidatedReportCommand, } from "../commands/GetConsolidatedReportCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new GetConsolidatedReportCommand(input), ...args);
-};
-export async function* paginateGetConsolidatedReport(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateGetConsolidatedReport = createPaginator(WellArchitectedClient, GetConsolidatedReportCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListAnswersPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListAnswersCommand } from "../commands/ListAnswersCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListAnswersCommand(input), ...args);
-};
-export async function* paginateListAnswers(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListAnswers = createPaginator(WellArchitectedClient, ListAnswersCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListCheckDetailsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListCheckDetailsCommand, } from "../commands/ListCheckDetailsCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListCheckDetailsCommand(input), ...args);
-};
-export async function* paginateListCheckDetails(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListCheckDetails = createPaginator(WellArchitectedClient, ListCheckDetailsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListCheckSummariesPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListCheckSummariesCommand, } from "../commands/ListCheckSummariesCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListCheckSummariesCommand(input), ...args);
-};
-export async function* paginateListCheckSummaries(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListCheckSummaries = createPaginator(WellArchitectedClient, ListCheckSummariesCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListLensReviewImprovementsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListLensReviewImprovementsCommand, } from "../commands/ListLensReviewImprovementsCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListLensReviewImprovementsCommand(input), ...args);
-};
-export async function* paginateListLensReviewImprovements(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListLensReviewImprovements = createPaginator(WellArchitectedClient, ListLensReviewImprovementsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListLensReviewsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListLensReviewsCommand, } from "../commands/ListLensReviewsCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListLensReviewsCommand(input), ...args);
-};
-export async function* paginateListLensReviews(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListLensReviews = createPaginator(WellArchitectedClient, ListLensReviewsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListLensSharesPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListLensSharesCommand, } from "../commands/ListLensSharesCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListLensSharesCommand(input), ...args);
-};
-export async function* paginateListLensShares(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListLensShares = createPaginator(WellArchitectedClient, ListLensSharesCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListLensesPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListLensesCommand } from "../commands/ListLensesCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListLensesCommand(input), ...args);
-};
-export async function* paginateListLenses(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListLenses = createPaginator(WellArchitectedClient, ListLensesCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListMilestonesPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListMilestonesCommand, } from "../commands/ListMilestonesCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListMilestonesCommand(input), ...args);
-};
-export async function* paginateListMilestones(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListMilestones = createPaginator(WellArchitectedClient, ListMilestonesCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListNotificationsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListNotificationsCommand, } from "../commands/ListNotificationsCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListNotificationsCommand(input), ...args);
-};
-export async function* paginateListNotifications(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListNotifications = createPaginator(WellArchitectedClient, ListNotificationsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListProfileNotificationsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListProfileNotificationsCommand, } from "../commands/ListProfileNotificationsCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListProfileNotificationsCommand(input), ...args);
-};
-export async function* paginateListProfileNotifications(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListProfileNotifications = createPaginator(WellArchitectedClient, ListProfileNotificationsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListProfileSharesPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListProfileSharesCommand, } from "../commands/ListProfileSharesCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListProfileSharesCommand(input), ...args);
-};
-export async function* paginateListProfileShares(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListProfileShares = createPaginator(WellArchitectedClient, ListProfileSharesCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListProfilesPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListProfilesCommand, } from "../commands/ListProfilesCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListProfilesCommand(input), ...args);
-};
-export async function* paginateListProfiles(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListProfiles = createPaginator(WellArchitectedClient, ListProfilesCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListReviewTemplateAnswersPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListReviewTemplateAnswersCommand, } from "../commands/ListReviewTemplateAnswersCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListReviewTemplateAnswersCommand(input), ...args);
-};
-export async function* paginateListReviewTemplateAnswers(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListReviewTemplateAnswers = createPaginator(WellArchitectedClient, ListReviewTemplateAnswersCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListReviewTemplatesPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListReviewTemplatesCommand, } from "../commands/ListReviewTemplatesCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListReviewTemplatesCommand(input), ...args);
-};
-export async function* paginateListReviewTemplates(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListReviewTemplates = createPaginator(WellArchitectedClient, ListReviewTemplatesCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListShareInvitationsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListShareInvitationsCommand, } from "../commands/ListShareInvitationsCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListShareInvitationsCommand(input), ...args);
-};
-export async function* paginateListShareInvitations(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListShareInvitations = createPaginator(WellArchitectedClient, ListShareInvitationsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListTemplateSharesPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListTemplateSharesCommand, } from "../commands/ListTemplateSharesCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListTemplateSharesCommand(input), ...args);
-};
-export async function* paginateListTemplateShares(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListTemplateShares = createPaginator(WellArchitectedClient, ListTemplateSharesCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListWorkloadSharesPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListWorkloadSharesCommand, } from "../commands/ListWorkloadSharesCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListWorkloadSharesCommand(input), ...args);
-};
-export async function* paginateListWorkloadShares(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListWorkloadShares = createPaginator(WellArchitectedClient, ListWorkloadSharesCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListWorkloadsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListWorkloadsCommand, } from "../commands/ListWorkloadsCommand";
 import { WellArchitectedClient } from "../WellArchitectedClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListWorkloadsCommand(input), ...args);
-};
-export async function* paginateListWorkloads(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 WellArchitectedClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected WellArchitected | WellArchitectedClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListWorkloads = createPaginator(WellArchitectedClient, ListWorkloadsCommand, "NextToken", "NextToken", "MaxResults");