@aws-sdk/client-wisdom 3.35.0

package/src/pagination/Interfaces.ts

@@ -0,0 +1,8 @@
+import { PaginationConfiguration } from "@aws-sdk/types";
+
+import { Wisdom } from "../Wisdom";
+import { WisdomClient } from "../WisdomClient";
+
+export interface WisdomPaginationConfiguration extends PaginationConfiguration {
+  client: Wisdom | WisdomClient;
+}

package/src/pagination/ListAssistantAssociationsPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  ListAssistantAssociationsCommand,
+  ListAssistantAssociationsCommandInput,
+  ListAssistantAssociationsCommandOutput,
+} from "../commands/ListAssistantAssociationsCommand";
+import { Wisdom } from "../Wisdom";
+import { WisdomClient } from "../WisdomClient";
+import { WisdomPaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: WisdomClient,
+  input: ListAssistantAssociationsCommandInput,
+  ...args: any
+): Promise<ListAssistantAssociationsCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new ListAssistantAssociationsCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: Wisdom,
+  input: ListAssistantAssociationsCommandInput,
+  ...args: any
+): Promise<ListAssistantAssociationsCommandOutput> => {
+  // @ts-ignore
+  return await client.listAssistantAssociations(input, ...args);
+};
+export async function* paginateListAssistantAssociations(
+  config: WisdomPaginationConfiguration,
+  input: ListAssistantAssociationsCommandInput,
+  ...additionalArguments: any
+): Paginator<ListAssistantAssociationsCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.nextToken
+  let token: typeof input.nextToken | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: ListAssistantAssociationsCommandOutput;
+  while (hasNext) {
+    input.nextToken = token;
+    input["maxResults"] = config.pageSize;
+    if (config.client instanceof Wisdom) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof WisdomClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected Wisdom | WisdomClient");
+    }
+    yield page;
+    token = page.nextToken;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/ListAssistantsPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  ListAssistantsCommand,
+  ListAssistantsCommandInput,
+  ListAssistantsCommandOutput,
+} from "../commands/ListAssistantsCommand";
+import { Wisdom } from "../Wisdom";
+import { WisdomClient } from "../WisdomClient";
+import { WisdomPaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: WisdomClient,
+  input: ListAssistantsCommandInput,
+  ...args: any
+): Promise<ListAssistantsCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new ListAssistantsCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: Wisdom,
+  input: ListAssistantsCommandInput,
+  ...args: any
+): Promise<ListAssistantsCommandOutput> => {
+  // @ts-ignore
+  return await client.listAssistants(input, ...args);
+};
+export async function* paginateListAssistants(
+  config: WisdomPaginationConfiguration,
+  input: ListAssistantsCommandInput,
+  ...additionalArguments: any
+): Paginator<ListAssistantsCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.nextToken
+  let token: typeof input.nextToken | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: ListAssistantsCommandOutput;
+  while (hasNext) {
+    input.nextToken = token;
+    input["maxResults"] = config.pageSize;
+    if (config.client instanceof Wisdom) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof WisdomClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected Wisdom | WisdomClient");
+    }
+    yield page;
+    token = page.nextToken;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/ListContentsPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  ListContentsCommand,
+  ListContentsCommandInput,
+  ListContentsCommandOutput,
+} from "../commands/ListContentsCommand";
+import { Wisdom } from "../Wisdom";
+import { WisdomClient } from "../WisdomClient";
+import { WisdomPaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: WisdomClient,
+  input: ListContentsCommandInput,
+  ...args: any
+): Promise<ListContentsCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new ListContentsCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: Wisdom,
+  input: ListContentsCommandInput,
+  ...args: any
+): Promise<ListContentsCommandOutput> => {
+  // @ts-ignore
+  return await client.listContents(input, ...args);
+};
+export async function* paginateListContents(
+  config: WisdomPaginationConfiguration,
+  input: ListContentsCommandInput,
+  ...additionalArguments: any
+): Paginator<ListContentsCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.nextToken
+  let token: typeof input.nextToken | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: ListContentsCommandOutput;
+  while (hasNext) {
+    input.nextToken = token;
+    input["maxResults"] = config.pageSize;
+    if (config.client instanceof Wisdom) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof WisdomClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected Wisdom | WisdomClient");
+    }
+    yield page;
+    token = page.nextToken;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/ListKnowledgeBasesPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  ListKnowledgeBasesCommand,
+  ListKnowledgeBasesCommandInput,
+  ListKnowledgeBasesCommandOutput,
+} from "../commands/ListKnowledgeBasesCommand";
+import { Wisdom } from "../Wisdom";
+import { WisdomClient } from "../WisdomClient";
+import { WisdomPaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: WisdomClient,
+  input: ListKnowledgeBasesCommandInput,
+  ...args: any
+): Promise<ListKnowledgeBasesCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new ListKnowledgeBasesCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: Wisdom,
+  input: ListKnowledgeBasesCommandInput,
+  ...args: any
+): Promise<ListKnowledgeBasesCommandOutput> => {
+  // @ts-ignore
+  return await client.listKnowledgeBases(input, ...args);
+};
+export async function* paginateListKnowledgeBases(
+  config: WisdomPaginationConfiguration,
+  input: ListKnowledgeBasesCommandInput,
+  ...additionalArguments: any
+): Paginator<ListKnowledgeBasesCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.nextToken
+  let token: typeof input.nextToken | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: ListKnowledgeBasesCommandOutput;
+  while (hasNext) {
+    input.nextToken = token;
+    input["maxResults"] = config.pageSize;
+    if (config.client instanceof Wisdom) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof WisdomClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected Wisdom | WisdomClient");
+    }
+    yield page;
+    token = page.nextToken;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/QueryAssistantPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  QueryAssistantCommand,
+  QueryAssistantCommandInput,
+  QueryAssistantCommandOutput,
+} from "../commands/QueryAssistantCommand";
+import { Wisdom } from "../Wisdom";
+import { WisdomClient } from "../WisdomClient";
+import { WisdomPaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: WisdomClient,
+  input: QueryAssistantCommandInput,
+  ...args: any
+): Promise<QueryAssistantCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new QueryAssistantCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: Wisdom,
+  input: QueryAssistantCommandInput,
+  ...args: any
+): Promise<QueryAssistantCommandOutput> => {
+  // @ts-ignore
+  return await client.queryAssistant(input, ...args);
+};
+export async function* paginateQueryAssistant(
+  config: WisdomPaginationConfiguration,
+  input: QueryAssistantCommandInput,
+  ...additionalArguments: any
+): Paginator<QueryAssistantCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.nextToken
+  let token: typeof input.nextToken | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: QueryAssistantCommandOutput;
+  while (hasNext) {
+    input.nextToken = token;
+    input["maxResults"] = config.pageSize;
+    if (config.client instanceof Wisdom) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof WisdomClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected Wisdom | WisdomClient");
+    }
+    yield page;
+    token = page.nextToken;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/SearchContentPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  SearchContentCommand,
+  SearchContentCommandInput,
+  SearchContentCommandOutput,
+} from "../commands/SearchContentCommand";
+import { Wisdom } from "../Wisdom";
+import { WisdomClient } from "../WisdomClient";
+import { WisdomPaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: WisdomClient,
+  input: SearchContentCommandInput,
+  ...args: any
+): Promise<SearchContentCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new SearchContentCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: Wisdom,
+  input: SearchContentCommandInput,
+  ...args: any
+): Promise<SearchContentCommandOutput> => {
+  // @ts-ignore
+  return await client.searchContent(input, ...args);
+};
+export async function* paginateSearchContent(
+  config: WisdomPaginationConfiguration,
+  input: SearchContentCommandInput,
+  ...additionalArguments: any
+): Paginator<SearchContentCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.nextToken
+  let token: typeof input.nextToken | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: SearchContentCommandOutput;
+  while (hasNext) {
+    input.nextToken = token;
+    input["maxResults"] = config.pageSize;
+    if (config.client instanceof Wisdom) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof WisdomClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected Wisdom | WisdomClient");
+    }
+    yield page;
+    token = page.nextToken;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/SearchSessionsPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  SearchSessionsCommand,
+  SearchSessionsCommandInput,
+  SearchSessionsCommandOutput,
+} from "../commands/SearchSessionsCommand";
+import { Wisdom } from "../Wisdom";
+import { WisdomClient } from "../WisdomClient";
+import { WisdomPaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: WisdomClient,
+  input: SearchSessionsCommandInput,
+  ...args: any
+): Promise<SearchSessionsCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new SearchSessionsCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: Wisdom,
+  input: SearchSessionsCommandInput,
+  ...args: any
+): Promise<SearchSessionsCommandOutput> => {
+  // @ts-ignore
+  return await client.searchSessions(input, ...args);
+};
+export async function* paginateSearchSessions(
+  config: WisdomPaginationConfiguration,
+  input: SearchSessionsCommandInput,
+  ...additionalArguments: any
+): Paginator<SearchSessionsCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.nextToken
+  let token: typeof input.nextToken | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: SearchSessionsCommandOutput;
+  while (hasNext) {
+    input.nextToken = token;
+    input["maxResults"] = config.pageSize;
+    if (config.client instanceof Wisdom) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof WisdomClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected Wisdom | WisdomClient");
+    }
+    yield page;
+    token = page.nextToken;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}