@aws-sdk/client-qconnect 3.461.0

package/dist-es/models/models_0.js

@@ -0,0 +1,508 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { QConnectServiceException as __BaseException } from "./QConnectServiceException";
+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 class ConflictException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConflictException.prototype);
+    }
+}
+export var AssistantAssociationInputData;
+(function (AssistantAssociationInputData) {
+    AssistantAssociationInputData.visit = (value, visitor) => {
+        if (value.knowledgeBaseId !== undefined)
+            return visitor.knowledgeBaseId(value.knowledgeBaseId);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AssistantAssociationInputData || (AssistantAssociationInputData = {}));
+export const AssociationType = {
+    KNOWLEDGE_BASE: "KNOWLEDGE_BASE",
+};
+export var AssistantAssociationOutputData;
+(function (AssistantAssociationOutputData) {
+    AssistantAssociationOutputData.visit = (value, visitor) => {
+        if (value.knowledgeBaseAssociation !== undefined)
+            return visitor.knowledgeBaseAssociation(value.knowledgeBaseAssociation);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AssistantAssociationOutputData || (AssistantAssociationOutputData = {}));
+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.resourceName = opts.resourceName;
+    }
+}
+export class ServiceQuotaExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceQuotaExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+    }
+}
+export class ValidationException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ValidationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ValidationException.prototype);
+    }
+}
+export const AssistantType = {
+    AGENT: "AGENT",
+};
+export const AssistantCapabilityType = {
+    V1: "V1",
+    V2: "V2",
+};
+export const AssistantStatus = {
+    ACTIVE: "ACTIVE",
+    CREATE_FAILED: "CREATE_FAILED",
+    CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
+    DELETED: "DELETED",
+    DELETE_FAILED: "DELETE_FAILED",
+    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
+};
+export const RelevanceLevel = {
+    HIGH: "HIGH",
+    LOW: "LOW",
+    MEDIUM: "MEDIUM",
+};
+export const SourceContentType = {
+    KNOWLEDGE_CONTENT: "KNOWLEDGE_CONTENT",
+};
+export var DataReference;
+(function (DataReference) {
+    DataReference.visit = (value, visitor) => {
+        if (value.contentReference !== undefined)
+            return visitor.contentReference(value.contentReference);
+        if (value.generativeReference !== undefined)
+            return visitor.generativeReference(value.generativeReference);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(DataReference || (DataReference = {}));
+export const RecommendationType = {
+    GENERATIVE_ANSWER: "GENERATIVE_ANSWER",
+    GENERATIVE_RESPONSE: "GENERATIVE_RESPONSE",
+    KNOWLEDGE_CONTENT: "KNOWLEDGE_CONTENT",
+};
+export var RecommendationTriggerData;
+(function (RecommendationTriggerData) {
+    RecommendationTriggerData.visit = (value, visitor) => {
+        if (value.query !== undefined)
+            return visitor.query(value.query);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RecommendationTriggerData || (RecommendationTriggerData = {}));
+export const RecommendationSourceType = {
+    ISSUE_DETECTION: "ISSUE_DETECTION",
+    OTHER: "OTHER",
+    RULE_EVALUATION: "RULE_EVALUATION",
+};
+export const RecommendationTriggerType = {
+    GENERATIVE: "GENERATIVE",
+    QUERY: "QUERY",
+};
+export const QueryConditionComparisonOperator = {
+    EQUALS: "EQUALS",
+};
+export const QueryConditionFieldName = {
+    RESULT_TYPE: "RESULT_TYPE",
+};
+export var QueryCondition;
+(function (QueryCondition) {
+    QueryCondition.visit = (value, visitor) => {
+        if (value.single !== undefined)
+            return visitor.single(value.single);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(QueryCondition || (QueryCondition = {}));
+export const QueryResultType = {
+    GENERATIVE_ANSWER: "GENERATIVE_ANSWER",
+    KNOWLEDGE_CONTENT: "KNOWLEDGE_CONTENT",
+};
+export class RequestTimeoutException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "RequestTimeoutException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "RequestTimeoutException";
+        this.$fault = "client";
+        this.$retryable = {};
+        Object.setPrototypeOf(this, RequestTimeoutException.prototype);
+    }
+}
+export const FilterField = {
+    NAME: "NAME",
+};
+export const FilterOperator = {
+    EQUALS: "EQUALS",
+};
+export var Configuration;
+(function (Configuration) {
+    Configuration.visit = (value, visitor) => {
+        if (value.connectConfiguration !== undefined)
+            return visitor.connectConfiguration(value.connectConfiguration);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(Configuration || (Configuration = {}));
+export const ContentStatus = {
+    ACTIVE: "ACTIVE",
+    CREATE_FAILED: "CREATE_FAILED",
+    CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
+    DELETED: "DELETED",
+    DELETE_FAILED: "DELETE_FAILED",
+    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
+    UPDATE_FAILED: "UPDATE_FAILED",
+};
+export class PreconditionFailedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "PreconditionFailedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "PreconditionFailedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, PreconditionFailedException.prototype);
+    }
+}
+export const KnowledgeBaseType = {
+    CUSTOM: "CUSTOM",
+    EXTERNAL: "EXTERNAL",
+    QUICK_RESPONSES: "QUICK_RESPONSES",
+};
+export var SourceConfiguration;
+(function (SourceConfiguration) {
+    SourceConfiguration.visit = (value, visitor) => {
+        if (value.appIntegrations !== undefined)
+            return visitor.appIntegrations(value.appIntegrations);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(SourceConfiguration || (SourceConfiguration = {}));
+export const KnowledgeBaseStatus = {
+    ACTIVE: "ACTIVE",
+    CREATE_FAILED: "CREATE_FAILED",
+    CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
+    DELETED: "DELETED",
+    DELETE_FAILED: "DELETE_FAILED",
+    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
+};
+export var QuickResponseDataProvider;
+(function (QuickResponseDataProvider) {
+    QuickResponseDataProvider.visit = (value, visitor) => {
+        if (value.content !== undefined)
+            return visitor.content(value.content);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(QuickResponseDataProvider || (QuickResponseDataProvider = {}));
+export var QuickResponseContentProvider;
+(function (QuickResponseContentProvider) {
+    QuickResponseContentProvider.visit = (value, visitor) => {
+        if (value.content !== undefined)
+            return visitor.content(value.content);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(QuickResponseContentProvider || (QuickResponseContentProvider = {}));
+export const QuickResponseStatus = {
+    CREATED: "CREATED",
+    CREATE_FAILED: "CREATE_FAILED",
+    CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
+    DELETED: "DELETED",
+    DELETE_FAILED: "DELETE_FAILED",
+    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
+    UPDATE_FAILED: "UPDATE_FAILED",
+    UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
+};
+export const ExternalSource = {
+    AMAZON_CONNECT: "AMAZON_CONNECT",
+};
+export const ImportJobType = {
+    QUICK_RESPONSES: "QUICK_RESPONSES",
+};
+export const ImportJobStatus = {
+    COMPLETE: "COMPLETE",
+    DELETED: "DELETED",
+    DELETE_FAILED: "DELETE_FAILED",
+    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
+    FAILED: "FAILED",
+    START_IN_PROGRESS: "START_IN_PROGRESS",
+};
+export const QuickResponseFilterOperator = {
+    EQUALS: "EQUALS",
+    PREFIX: "PREFIX",
+};
+export const Order = {
+    ASC: "ASC",
+    DESC: "DESC",
+};
+export const QuickResponseQueryOperator = {
+    CONTAINS: "CONTAINS",
+    CONTAINS_AND_PREFIX: "CONTAINS_AND_PREFIX",
+};
+export const Priority = {
+    HIGH: "HIGH",
+    LOW: "LOW",
+    MEDIUM: "MEDIUM",
+};
+export class TooManyTagsException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "TooManyTagsException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "TooManyTagsException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, TooManyTagsException.prototype);
+        this.resourceName = opts.resourceName;
+    }
+}
+export var DataDetails;
+(function (DataDetails) {
+    DataDetails.visit = (value, visitor) => {
+        if (value.contentData !== undefined)
+            return visitor.contentData(value.contentData);
+        if (value.generativeData !== undefined)
+            return visitor.generativeData(value.generativeData);
+        if (value.sourceContentData !== undefined)
+            return visitor.sourceContentData(value.sourceContentData);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(DataDetails || (DataDetails = {}));
+export const DocumentTextFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: SENSITIVE_STRING }),
+});
+export const TextDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.title && { title: DocumentTextFilterSensitiveLog(obj.title) }),
+    ...(obj.excerpt && { excerpt: DocumentTextFilterSensitiveLog(obj.excerpt) }),
+});
+export const ContentDataDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.textData && { textData: TextDataFilterSensitiveLog(obj.textData) }),
+});
+export const SourceContentDataDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.textData && { textData: TextDataFilterSensitiveLog(obj.textData) }),
+});
+export const DocumentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.title && { title: DocumentTextFilterSensitiveLog(obj.title) }),
+    ...(obj.excerpt && { excerpt: DocumentTextFilterSensitiveLog(obj.excerpt) }),
+});
+export const QueryRecommendationTriggerDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: SENSITIVE_STRING }),
+});
+export const RecommendationTriggerDataFilterSensitiveLog = (obj) => {
+    if (obj.query !== undefined)
+        return { query: QueryRecommendationTriggerDataFilterSensitiveLog(obj.query) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const RecommendationTriggerFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.data && { data: RecommendationTriggerDataFilterSensitiveLog(obj.data) }),
+});
+export const QueryAssistantRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.queryText && { queryText: SENSITIVE_STRING }),
+    ...(obj.queryCondition && { queryCondition: obj.queryCondition.map((item) => item) }),
+});
+export const ContentDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.url && { url: SENSITIVE_STRING }),
+});
+export const CreateContentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: ContentDataFilterSensitiveLog(obj.content) }),
+});
+export const GetContentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: ContentDataFilterSensitiveLog(obj.content) }),
+});
+export const UpdateContentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: ContentDataFilterSensitiveLog(obj.content) }),
+});
+export const QuickResponseDataProviderFilterSensitiveLog = (obj) => {
+    if (obj.content !== undefined)
+        return { content: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const GroupingConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.criteria && { criteria: SENSITIVE_STRING }),
+    ...(obj.values && { values: SENSITIVE_STRING }),
+});
+export const CreateQuickResponseRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: QuickResponseDataProviderFilterSensitiveLog(obj.content) }),
+    ...(obj.groupingConfiguration && {
+        groupingConfiguration: GroupingConfigurationFilterSensitiveLog(obj.groupingConfiguration),
+    }),
+    ...(obj.channels && { channels: SENSITIVE_STRING }),
+});
+export const QuickResponseContentProviderFilterSensitiveLog = (obj) => {
+    if (obj.content !== undefined)
+        return { content: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const QuickResponseContentsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.plainText && { plainText: QuickResponseContentProviderFilterSensitiveLog(obj.plainText) }),
+    ...(obj.markdown && { markdown: QuickResponseContentProviderFilterSensitiveLog(obj.markdown) }),
+});
+export const QuickResponseDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.contents && { contents: QuickResponseContentsFilterSensitiveLog(obj.contents) }),
+    ...(obj.groupingConfiguration && {
+        groupingConfiguration: GroupingConfigurationFilterSensitiveLog(obj.groupingConfiguration),
+    }),
+    ...(obj.channels && { channels: SENSITIVE_STRING }),
+});
+export const CreateQuickResponseResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.quickResponse && { quickResponse: QuickResponseDataFilterSensitiveLog(obj.quickResponse) }),
+});
+export const ImportJobDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.url && { url: SENSITIVE_STRING }),
+    ...(obj.failedRecordReport && { failedRecordReport: SENSITIVE_STRING }),
+    ...(obj.externalSourceConfiguration && { externalSourceConfiguration: obj.externalSourceConfiguration }),
+});
+export const GetImportJobResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.importJob && { importJob: ImportJobDataFilterSensitiveLog(obj.importJob) }),
+});
+export const GetQuickResponseResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.quickResponse && { quickResponse: QuickResponseDataFilterSensitiveLog(obj.quickResponse) }),
+});
+export const QuickResponseSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.channels && { channels: SENSITIVE_STRING }),
+});
+export const ListQuickResponsesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.quickResponseSummaries && {
+        quickResponseSummaries: obj.quickResponseSummaries.map((item) => QuickResponseSummaryFilterSensitiveLog(item)),
+    }),
+});
+export const UpdateQuickResponseRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: QuickResponseDataProviderFilterSensitiveLog(obj.content) }),
+    ...(obj.groupingConfiguration && {
+        groupingConfiguration: GroupingConfigurationFilterSensitiveLog(obj.groupingConfiguration),
+    }),
+    ...(obj.channels && { channels: SENSITIVE_STRING }),
+});
+export const UpdateQuickResponseResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.quickResponse && { quickResponse: QuickResponseDataFilterSensitiveLog(obj.quickResponse) }),
+});
+export const SearchQuickResponsesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.attributes && { attributes: SENSITIVE_STRING }),
+});
+export const QuickResponseSearchResultDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.contents && { contents: QuickResponseContentsFilterSensitiveLog(obj.contents) }),
+    ...(obj.groupingConfiguration && {
+        groupingConfiguration: GroupingConfigurationFilterSensitiveLog(obj.groupingConfiguration),
+    }),
+    ...(obj.channels && { channels: SENSITIVE_STRING }),
+    ...(obj.attributesNotInterpolated && { attributesNotInterpolated: SENSITIVE_STRING }),
+    ...(obj.attributesInterpolated && { attributesInterpolated: SENSITIVE_STRING }),
+});
+export const SearchQuickResponsesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.results && { results: obj.results.map((item) => QuickResponseSearchResultDataFilterSensitiveLog(item)) }),
+});
+export const StartContentUploadResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.url && { url: SENSITIVE_STRING }),
+});
+export const StartImportJobResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.importJob && { importJob: ImportJobDataFilterSensitiveLog(obj.importJob) }),
+});
+export const DataDetailsFilterSensitiveLog = (obj) => {
+    if (obj.contentData !== undefined)
+        return { contentData: ContentDataDetailsFilterSensitiveLog(obj.contentData) };
+    if (obj.generativeData !== undefined)
+        return { generativeData: GenerativeDataDetailsFilterSensitiveLog(obj.generativeData) };
+    if (obj.sourceContentData !== undefined)
+        return { sourceContentData: SourceContentDataDetailsFilterSensitiveLog(obj.sourceContentData) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const DataSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.reference && { reference: obj.reference }),
+    ...(obj.details && { details: DataDetailsFilterSensitiveLog(obj.details) }),
+});
+export const GenerativeDataDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.completion && { completion: SENSITIVE_STRING }),
+    ...(obj.references && { references: obj.references.map((item) => DataSummaryFilterSensitiveLog(item)) }),
+});
+export const RecommendationDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.document && { document: DocumentFilterSensitiveLog(obj.document) }),
+    ...(obj.data && { data: DataSummaryFilterSensitiveLog(obj.data) }),
+});
+export const ResultDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.document && { document: DocumentFilterSensitiveLog(obj.document) }),
+    ...(obj.data && { data: DataSummaryFilterSensitiveLog(obj.data) }),
+});
+export const GetRecommendationsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.recommendations && {
+        recommendations: obj.recommendations.map((item) => RecommendationDataFilterSensitiveLog(item)),
+    }),
+    ...(obj.triggers && { triggers: obj.triggers.map((item) => RecommendationTriggerFilterSensitiveLog(item)) }),
+});
+export const QueryAssistantResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.results && { results: obj.results.map((item) => ResultDataFilterSensitiveLog(item)) }),
+});

package/dist-es/pagination/Interfaces.js

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

package/dist-es/pagination/ListAssistantAssociationsPaginator.js

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

package/dist-es/pagination/ListAssistantsPaginator.js

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

package/dist-es/pagination/ListContentsPaginator.js

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

package/dist-es/pagination/ListImportJobsPaginator.js

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

package/dist-es/pagination/ListKnowledgeBasesPaginator.js

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

package/dist-es/pagination/ListQuickResponsesPaginator.js

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