@aws-sdk/client-qbusiness 3.461.0

package/dist-es/models/models_0.js

@@ -0,0 +1,378 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { QBusinessServiceException as __BaseException } from "./QBusinessServiceException";
+export const MemberRelation = {
+    AND: "AND",
+    OR: "OR",
+};
+export const ReadAccessType = {
+    ALLOW: "ALLOW",
+    DENY: "DENY",
+};
+export const MembershipType = {
+    DATASOURCE: "DATASOURCE",
+    INDEX: "INDEX",
+};
+export var Principal;
+(function (Principal) {
+    Principal.visit = (value, visitor) => {
+        if (value.user !== undefined)
+            return visitor.user(value.user);
+        if (value.group !== undefined)
+            return visitor.group(value.group);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(Principal || (Principal = {}));
+export class AccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "AccessDeniedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+    }
+}
+export const ActionPayloadFieldType = {
+    ARRAY: "ARRAY",
+    BOOLEAN: "BOOLEAN",
+    NUMBER: "NUMBER",
+    STRING: "STRING",
+};
+export const PluginType = {
+    JIRA: "JIRA",
+    SALESFORCE: "SALESFORCE",
+    SERVICE_NOW: "SERVICE_NOW",
+    ZENDESK: "ZENDESK",
+};
+export const ApplicationStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+    UPDATING: "UPDATING",
+};
+export class ConflictException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConflictException.prototype);
+        this.resourceId = opts.resourceId;
+        this.resourceType = opts.resourceType;
+    }
+}
+export const AttachmentsControlMode = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+export class InternalServerException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalServerException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.resourceId = opts.resourceId;
+        this.resourceType = opts.resourceType;
+    }
+}
+export class ServiceQuotaExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceQuotaExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+        this.resourceId = opts.resourceId;
+        this.resourceType = opts.resourceType;
+    }
+}
+export class ThrottlingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+    }
+}
+export const ValidationExceptionReason = {
+    CANNOT_PARSE: "CANNOT_PARSE",
+    FIELD_VALIDATION_FAILED: "FIELD_VALIDATION_FAILED",
+    UNKNOWN_OPERATION: "UNKNOWN_OPERATION",
+};
+export class ValidationException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ValidationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.reason = opts.reason;
+        this.fields = opts.fields;
+    }
+}
+export const ErrorCode = {
+    INTERNAL_ERROR: "InternalError",
+    INVALID_REQUEST: "InvalidRequest",
+    RESOURCE_INACTIVE: "ResourceInactive",
+    RESOURCE_NOT_FOUND: "ResourceNotFound",
+};
+export const DocumentEnrichmentConditionOperator = {
+    BEGINS_WITH: "BEGINS_WITH",
+    CONTAINS: "CONTAINS",
+    EQUALS: "EQUALS",
+    EXISTS: "EXISTS",
+    GREATER_THAN: "GREATER_THAN",
+    GREATER_THAN_OR_EQUALS: "GREATER_THAN_OR_EQUALS",
+    LESS_THAN: "LESS_THAN",
+    LESS_THAN_OR_EQUALS: "LESS_THAN_OR_EQUALS",
+    NOT_CONTAINS: "NOT_CONTAINS",
+    NOT_EQUALS: "NOT_EQUALS",
+    NOT_EXISTS: "NOT_EXISTS",
+};
+export var DocumentAttributeValue;
+(function (DocumentAttributeValue) {
+    DocumentAttributeValue.visit = (value, visitor) => {
+        if (value.stringValue !== undefined)
+            return visitor.stringValue(value.stringValue);
+        if (value.stringListValue !== undefined)
+            return visitor.stringListValue(value.stringListValue);
+        if (value.longValue !== undefined)
+            return visitor.longValue(value.longValue);
+        if (value.dateValue !== undefined)
+            return visitor.dateValue(value.dateValue);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(DocumentAttributeValue || (DocumentAttributeValue = {}));
+export const DocumentContentOperator = {
+    DELETE: "DELETE",
+};
+export const AttributeValueOperator = {
+    DELETE: "DELETE",
+};
+export const DataSourceStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+    PENDING_CREATION: "PENDING_CREATION",
+    UPDATING: "UPDATING",
+};
+export const Status = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+export const AttributeType = {
+    DATE: "DATE",
+    NUMBER: "NUMBER",
+    STRING: "STRING",
+    STRING_LIST: "STRING_LIST",
+};
+export const IndexStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+    UPDATING: "UPDATING",
+};
+export var PluginAuthConfiguration;
+(function (PluginAuthConfiguration) {
+    PluginAuthConfiguration.visit = (value, visitor) => {
+        if (value.basicAuthConfiguration !== undefined)
+            return visitor.basicAuthConfiguration(value.basicAuthConfiguration);
+        if (value.oAuth2ClientCredentialConfiguration !== undefined)
+            return visitor.oAuth2ClientCredentialConfiguration(value.oAuth2ClientCredentialConfiguration);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PluginAuthConfiguration || (PluginAuthConfiguration = {}));
+export const PluginState = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+export var RetrieverConfiguration;
+(function (RetrieverConfiguration) {
+    RetrieverConfiguration.visit = (value, visitor) => {
+        if (value.nativeIndexConfiguration !== undefined)
+            return visitor.nativeIndexConfiguration(value.nativeIndexConfiguration);
+        if (value.kendraIndexConfiguration !== undefined)
+            return visitor.kendraIndexConfiguration(value.kendraIndexConfiguration);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RetrieverConfiguration || (RetrieverConfiguration = {}));
+export const RetrieverType = {
+    KENDRA_INDEX: "KENDRA_INDEX",
+    NATIVE_INDEX: "NATIVE_INDEX",
+};
+export const RetrieverStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    FAILED: "FAILED",
+};
+export const WebExperienceSamplePromptsControlMode = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+export var WebExperienceAuthConfiguration;
+(function (WebExperienceAuthConfiguration) {
+    WebExperienceAuthConfiguration.visit = (value, visitor) => {
+        if (value.samlConfiguration !== undefined)
+            return visitor.samlConfiguration(value.samlConfiguration);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(WebExperienceAuthConfiguration || (WebExperienceAuthConfiguration = {}));
+export const WebExperienceStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+    PENDING_AUTH_CONFIG: "PENDING_AUTH_CONFIG",
+};
+export const AttachmentStatus = {
+    FAILED: "FAILED",
+    SUCCEEDED: "SUCCEEDED",
+};
+export var DocumentContent;
+(function (DocumentContent) {
+    DocumentContent.visit = (value, visitor) => {
+        if (value.blob !== undefined)
+            return visitor.blob(value.blob);
+        if (value.s3 !== undefined)
+            return visitor.s3(value.s3);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(DocumentContent || (DocumentContent = {}));
+export const ContentType = {
+    CSV: "CSV",
+    HTML: "HTML",
+    JSON: "JSON",
+    MD: "MD",
+    MS_EXCEL: "MS_EXCEL",
+    MS_WORD: "MS_WORD",
+    PDF: "PDF",
+    PLAIN_TEXT: "PLAIN_TEXT",
+    PPT: "PPT",
+    RTF: "RTF",
+    XML: "XML",
+    XSLT: "XSLT",
+};
+export class LicenseNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "LicenseNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "LicenseNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, LicenseNotFoundException.prototype);
+    }
+}
+export const DataSourceSyncJobStatus = {
+    ABORTED: "ABORTED",
+    FAILED: "FAILED",
+    INCOMPLETE: "INCOMPLETE",
+    STOPPING: "STOPPING",
+    SUCCEEDED: "SUCCEEDED",
+    SYNCING: "SYNCING",
+    SYNCING_INDEXING: "SYNCING_INDEXING",
+};
+export const DocumentStatus = {
+    DELETED: "DELETED",
+    DELETING: "DELETING",
+    DOCUMENT_FAILED_TO_INDEX: "DOCUMENT_FAILED_TO_INDEX",
+    FAILED: "FAILED",
+    INDEXED: "INDEXED",
+    PROCESSING: "PROCESSING",
+    RECEIVED: "RECEIVED",
+    UPDATED: "UPDATED",
+};
+export const ResponseScope = {
+    ENTERPRISE_CONTENT_ONLY: "ENTERPRISE_CONTENT_ONLY",
+    EXTENDED_KNOWLEDGE_ENABLED: "EXTENDED_KNOWLEDGE_ENABLED",
+};
+export var RuleConfiguration;
+(function (RuleConfiguration) {
+    RuleConfiguration.visit = (value, visitor) => {
+        if (value.contentBlockerRule !== undefined)
+            return visitor.contentBlockerRule(value.contentBlockerRule);
+        if (value.contentRetrievalRule !== undefined)
+            return visitor.contentRetrievalRule(value.contentRetrievalRule);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RuleConfiguration || (RuleConfiguration = {}));
+export const RuleType = {
+    CONTENT_BLOCKER_RULE: "CONTENT_BLOCKER_RULE",
+    CONTENT_RETRIEVAL_RULE: "CONTENT_RETRIEVAL_RULE",
+};
+export const GroupStatus = {
+    DELETED: "DELETED",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+    PROCESSING: "PROCESSING",
+    SUCCEEDED: "SUCCEEDED",
+};
+export const MessageType = {
+    SYSTEM: "SYSTEM",
+    USER: "USER",
+};
+export const MessageUsefulnessReason = {
+    COMPLETE: "COMPLETE",
+    FACTUALLY_CORRECT: "FACTUALLY_CORRECT",
+    HARMFUL_OR_UNSAFE: "HARMFUL_OR_UNSAFE",
+    HELPFUL: "HELPFUL",
+    INCORRECT_OR_MISSING_SOURCES: "INCORRECT_OR_MISSING_SOURCES",
+    NOT_FACTUALLY_CORRECT: "NOT_FACTUALLY_CORRECT",
+    NOT_HELPFUL: "NOT_HELPFUL",
+    RELEVANT_SOURCES: "RELEVANT_SOURCES",
+};
+export const MessageUsefulness = {
+    NOT_USEFUL: "NOT_USEFUL",
+    USEFUL: "USEFUL",
+};
+export const EncryptionConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.kmsKeyId && { kmsKeyId: SENSITIVE_STRING }),
+});
+export const CreateApplicationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.encryptionConfiguration && {
+        encryptionConfiguration: EncryptionConfigurationFilterSensitiveLog(obj.encryptionConfiguration),
+    }),
+});
+export const GetApplicationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.encryptionConfiguration && {
+        encryptionConfiguration: EncryptionConfigurationFilterSensitiveLog(obj.encryptionConfiguration),
+    }),
+});

package/dist-es/pagination/GetChatControlsConfigurationPaginator.js

@@ -0,0 +1,25 @@
+import { GetChatControlsConfigurationCommand, } from "../commands/GetChatControlsConfigurationCommand";
+import { QBusinessClient } from "../QBusinessClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetChatControlsConfigurationCommand(input), ...args);
+};
+export async function* paginateGetChatControlsConfiguration(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 QBusinessClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected QBusiness | QBusinessClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/Interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist-es/pagination/ListApplicationsPaginator.js

@@ -0,0 +1,25 @@
+import { ListApplicationsCommand, } from "../commands/ListApplicationsCommand";
+import { QBusinessClient } from "../QBusinessClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListApplicationsCommand(input), ...args);
+};
+export async function* paginateListApplications(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 QBusinessClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected QBusiness | QBusinessClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListConversationsPaginator.js

@@ -0,0 +1,25 @@
+import { ListConversationsCommand, } from "../commands/ListConversationsCommand";
+import { QBusinessClient } from "../QBusinessClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListConversationsCommand(input), ...args);
+};
+export async function* paginateListConversations(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 QBusinessClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected QBusiness | QBusinessClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListDataSourceSyncJobsPaginator.js

@@ -0,0 +1,25 @@
+import { ListDataSourceSyncJobsCommand, } from "../commands/ListDataSourceSyncJobsCommand";
+import { QBusinessClient } from "../QBusinessClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDataSourceSyncJobsCommand(input), ...args);
+};
+export async function* paginateListDataSourceSyncJobs(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 QBusinessClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected QBusiness | QBusinessClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListDataSourcesPaginator.js

@@ -0,0 +1,25 @@
+import { ListDataSourcesCommand, } from "../commands/ListDataSourcesCommand";
+import { QBusinessClient } from "../QBusinessClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDataSourcesCommand(input), ...args);
+};
+export async function* paginateListDataSources(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 QBusinessClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected QBusiness | QBusinessClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListDocumentsPaginator.js

@@ -0,0 +1,25 @@
+import { ListDocumentsCommand, } from "../commands/ListDocumentsCommand";
+import { QBusinessClient } from "../QBusinessClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDocumentsCommand(input), ...args);
+};
+export async function* paginateListDocuments(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 QBusinessClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected QBusiness | QBusinessClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListGroupsPaginator.js

@@ -0,0 +1,25 @@
+import { ListGroupsCommand } from "../commands/ListGroupsCommand";
+import { QBusinessClient } from "../QBusinessClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListGroupsCommand(input), ...args);
+};
+export async function* paginateListGroups(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 QBusinessClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected QBusiness | QBusinessClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListIndicesPaginator.js

@@ -0,0 +1,25 @@
+import { ListIndicesCommand } from "../commands/ListIndicesCommand";
+import { QBusinessClient } from "../QBusinessClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListIndicesCommand(input), ...args);
+};
+export async function* paginateListIndices(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 QBusinessClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected QBusiness | QBusinessClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListMessagesPaginator.js

@@ -0,0 +1,25 @@
+import { ListMessagesCommand, } from "../commands/ListMessagesCommand";
+import { QBusinessClient } from "../QBusinessClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListMessagesCommand(input), ...args);
+};
+export async function* paginateListMessages(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 QBusinessClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected QBusiness | QBusinessClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListPluginsPaginator.js

@@ -0,0 +1,25 @@
+import { ListPluginsCommand } from "../commands/ListPluginsCommand";
+import { QBusinessClient } from "../QBusinessClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListPluginsCommand(input), ...args);
+};
+export async function* paginateListPlugins(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 QBusinessClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected QBusiness | QBusinessClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListRetrieversPaginator.js

@@ -0,0 +1,25 @@
+import { ListRetrieversCommand, } from "../commands/ListRetrieversCommand";
+import { QBusinessClient } from "../QBusinessClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListRetrieversCommand(input), ...args);
+};
+export async function* paginateListRetrievers(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 QBusinessClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected QBusiness | QBusinessClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}