@aws-sdk/client-lex-model-building-service 3.34.0 → 3.37.0

package/pagination/GetBotAliasesPaginator.ts

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

package/pagination/GetBotChannelAssociationsPaginator.ts

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

package/pagination/GetBotVersionsPaginator.ts

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

package/pagination/GetBotsPaginator.ts

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

package/pagination/GetBuiltinIntentsPaginator.ts

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

package/pagination/GetBuiltinSlotTypesPaginator.ts

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

package/pagination/GetIntentVersionsPaginator.ts

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

package/pagination/GetIntentsPaginator.ts

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

package/pagination/GetMigrationsPaginator.ts

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

package/pagination/GetSlotTypeVersionsPaginator.ts

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

package/pagination/GetSlotTypesPaginator.ts

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

package/pagination/Interfaces.ts

@@ -1,7 +0,0 @@
-import { LexModelBuildingService } from "../LexModelBuildingService";
-import { LexModelBuildingServiceClient } from "../LexModelBuildingServiceClient";
-import { PaginationConfiguration } from "@aws-sdk/types";
-
-export interface LexModelBuildingServicePaginationConfiguration extends PaginationConfiguration {
-  client: LexModelBuildingService | LexModelBuildingServiceClient;
-}