@aws-sdk/client-wellarchitected 3.477.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");

package/dist-types/pagination/GetConsolidatedReportPaginator.d.ts

@@ -4,4 +4,4 @@ import { WellArchitectedPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateGetConsolidatedReport(config: WellArchitectedPaginationConfiguration, input: GetConsolidatedReportCommandInput, ...additionalArguments: any): Paginator<GetConsolidatedReportCommandOutput>;
+export declare const paginateGetConsolidatedReport: (config: WellArchitectedPaginationConfiguration, input: GetConsolidatedReportCommandInput, ...rest: any[]) => Paginator<GetConsolidatedReportCommandOutput>;

package/dist-types/pagination/ListAnswersPaginator.d.ts

@@ -4,4 +4,4 @@ import { WellArchitectedPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListAnswers(config: WellArchitectedPaginationConfiguration, input: ListAnswersCommandInput, ...additionalArguments: any): Paginator<ListAnswersCommandOutput>;
+export declare const paginateListAnswers: (config: WellArchitectedPaginationConfiguration, input: ListAnswersCommandInput, ...rest: any[]) => Paginator<ListAnswersCommandOutput>;

package/dist-types/pagination/ListCheckDetailsPaginator.d.ts

@@ -4,4 +4,4 @@ import { WellArchitectedPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListCheckDetails(config: WellArchitectedPaginationConfiguration, input: ListCheckDetailsCommandInput, ...additionalArguments: any): Paginator<ListCheckDetailsCommandOutput>;
+export declare const paginateListCheckDetails: (config: WellArchitectedPaginationConfiguration, input: ListCheckDetailsCommandInput, ...rest: any[]) => Paginator<ListCheckDetailsCommandOutput>;

package/dist-types/pagination/ListCheckSummariesPaginator.d.ts

@@ -4,4 +4,4 @@ import { WellArchitectedPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListCheckSummaries(config: WellArchitectedPaginationConfiguration, input: ListCheckSummariesCommandInput, ...additionalArguments: any): Paginator<ListCheckSummariesCommandOutput>;
+export declare const paginateListCheckSummaries: (config: WellArchitectedPaginationConfiguration, input: ListCheckSummariesCommandInput, ...rest: any[]) => Paginator<ListCheckSummariesCommandOutput>;

package/dist-types/pagination/ListLensReviewImprovementsPaginator.d.ts

@@ -4,4 +4,4 @@ import { WellArchitectedPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListLensReviewImprovements(config: WellArchitectedPaginationConfiguration, input: ListLensReviewImprovementsCommandInput, ...additionalArguments: any): Paginator<ListLensReviewImprovementsCommandOutput>;
+export declare const paginateListLensReviewImprovements: (config: WellArchitectedPaginationConfiguration, input: ListLensReviewImprovementsCommandInput, ...rest: any[]) => Paginator<ListLensReviewImprovementsCommandOutput>;

package/dist-types/pagination/ListLensReviewsPaginator.d.ts

@@ -4,4 +4,4 @@ import { WellArchitectedPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListLensReviews(config: WellArchitectedPaginationConfiguration, input: ListLensReviewsCommandInput, ...additionalArguments: any): Paginator<ListLensReviewsCommandOutput>;
+export declare const paginateListLensReviews: (config: WellArchitectedPaginationConfiguration, input: ListLensReviewsCommandInput, ...rest: any[]) => Paginator<ListLensReviewsCommandOutput>;

package/dist-types/pagination/ListLensSharesPaginator.d.ts

@@ -4,4 +4,4 @@ import { WellArchitectedPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListLensShares(config: WellArchitectedPaginationConfiguration, input: ListLensSharesCommandInput, ...additionalArguments: any): Paginator<ListLensSharesCommandOutput>;
+export declare const paginateListLensShares: (config: WellArchitectedPaginationConfiguration, input: ListLensSharesCommandInput, ...rest: any[]) => Paginator<ListLensSharesCommandOutput>;

package/dist-types/pagination/ListLensesPaginator.d.ts

@@ -4,4 +4,4 @@ import { WellArchitectedPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListLenses(config: WellArchitectedPaginationConfiguration, input: ListLensesCommandInput, ...additionalArguments: any): Paginator<ListLensesCommandOutput>;
+export declare const paginateListLenses: (config: WellArchitectedPaginationConfiguration, input: ListLensesCommandInput, ...rest: any[]) => Paginator<ListLensesCommandOutput>;

package/dist-types/pagination/ListMilestonesPaginator.d.ts

@@ -4,4 +4,4 @@ import { WellArchitectedPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListMilestones(config: WellArchitectedPaginationConfiguration, input: ListMilestonesCommandInput, ...additionalArguments: any): Paginator<ListMilestonesCommandOutput>;
+export declare const paginateListMilestones: (config: WellArchitectedPaginationConfiguration, input: ListMilestonesCommandInput, ...rest: any[]) => Paginator<ListMilestonesCommandOutput>;

package/dist-types/pagination/ListNotificationsPaginator.d.ts

@@ -4,4 +4,4 @@ import { WellArchitectedPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListNotifications(config: WellArchitectedPaginationConfiguration, input: ListNotificationsCommandInput, ...additionalArguments: any): Paginator<ListNotificationsCommandOutput>;
+export declare const paginateListNotifications: (config: WellArchitectedPaginationConfiguration, input: ListNotificationsCommandInput, ...rest: any[]) => Paginator<ListNotificationsCommandOutput>;

package/dist-types/pagination/ListProfileNotificationsPaginator.d.ts

@@ -4,4 +4,4 @@ import { WellArchitectedPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListProfileNotifications(config: WellArchitectedPaginationConfiguration, input: ListProfileNotificationsCommandInput, ...additionalArguments: any): Paginator<ListProfileNotificationsCommandOutput>;
+export declare const paginateListProfileNotifications: (config: WellArchitectedPaginationConfiguration, input: ListProfileNotificationsCommandInput, ...rest: any[]) => Paginator<ListProfileNotificationsCommandOutput>;

package/dist-types/pagination/ListProfileSharesPaginator.d.ts

@@ -4,4 +4,4 @@ import { WellArchitectedPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListProfileShares(config: WellArchitectedPaginationConfiguration, input: ListProfileSharesCommandInput, ...additionalArguments: any): Paginator<ListProfileSharesCommandOutput>;
+export declare const paginateListProfileShares: (config: WellArchitectedPaginationConfiguration, input: ListProfileSharesCommandInput, ...rest: any[]) => Paginator<ListProfileSharesCommandOutput>;