@aws-sdk/client-connectcases 3.184.0

package/dist-es/models/models_0.js

@@ -0,0 +1,556 @@
+import { ConnectCasesServiceException as __BaseException } from "./ConnectCasesServiceException";
+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 FieldValueUnion;
+(function (FieldValueUnion) {
+    FieldValueUnion.visit = (value, visitor) => {
+        if (value.stringValue !== undefined)
+            return visitor.stringValue(value.stringValue);
+        if (value.doubleValue !== undefined)
+            return visitor.doubleValue(value.doubleValue);
+        if (value.booleanValue !== undefined)
+            return visitor.booleanValue(value.booleanValue);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(FieldValueUnion || (FieldValueUnion = {}));
+export class InternalServerException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalServerException";
+        this.$fault = "server";
+        this.$retryable = {};
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+        this.retryAfterSeconds = opts.retryAfterSeconds;
+    }
+}
+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 ThrottlingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        this.$retryable = {};
+        Object.setPrototypeOf(this, ThrottlingException.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 var CommentBodyTextType;
+(function (CommentBodyTextType) {
+    CommentBodyTextType["PLAINTEXT"] = "Text/Plain";
+})(CommentBodyTextType || (CommentBodyTextType = {}));
+export var RelatedItemInputContent;
+(function (RelatedItemInputContent) {
+    RelatedItemInputContent.visit = (value, visitor) => {
+        if (value.contact !== undefined)
+            return visitor.contact(value.contact);
+        if (value.comment !== undefined)
+            return visitor.comment(value.comment);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RelatedItemInputContent || (RelatedItemInputContent = {}));
+export var RelatedItemType;
+(function (RelatedItemType) {
+    RelatedItemType["COMMENT"] = "Comment";
+    RelatedItemType["CONTACT"] = "Contact";
+})(RelatedItemType || (RelatedItemType = {}));
+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 var RelatedItemTypeFilter;
+(function (RelatedItemTypeFilter) {
+    RelatedItemTypeFilter.visit = (value, visitor) => {
+        if (value.contact !== undefined)
+            return visitor.contact(value.contact);
+        if (value.comment !== undefined)
+            return visitor.comment(value.comment);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RelatedItemTypeFilter || (RelatedItemTypeFilter = {}));
+export var RelatedItemContent;
+(function (RelatedItemContent) {
+    RelatedItemContent.visit = (value, visitor) => {
+        if (value.contact !== undefined)
+            return visitor.contact(value.contact);
+        if (value.comment !== undefined)
+            return visitor.comment(value.comment);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RelatedItemContent || (RelatedItemContent = {}));
+export var FieldFilter;
+(function (FieldFilter) {
+    FieldFilter.visit = (value, visitor) => {
+        if (value.equalTo !== undefined)
+            return visitor.equalTo(value.equalTo);
+        if (value.contains !== undefined)
+            return visitor.contains(value.contains);
+        if (value.greaterThan !== undefined)
+            return visitor.greaterThan(value.greaterThan);
+        if (value.greaterThanOrEqualTo !== undefined)
+            return visitor.greaterThanOrEqualTo(value.greaterThanOrEqualTo);
+        if (value.lessThan !== undefined)
+            return visitor.lessThan(value.lessThan);
+        if (value.lessThanOrEqualTo !== undefined)
+            return visitor.lessThanOrEqualTo(value.lessThanOrEqualTo);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(FieldFilter || (FieldFilter = {}));
+export var Order;
+(function (Order) {
+    Order["ASCENDING"] = "Asc";
+    Order["DESCENDING"] = "Desc";
+})(Order || (Order = {}));
+export var DomainStatus;
+(function (DomainStatus) {
+    DomainStatus["ACTIVE"] = "Active";
+    DomainStatus["CREATION_FAILED"] = "CreationFailed";
+    DomainStatus["CREATION_IN_PROGRESS"] = "CreationInProgress";
+})(DomainStatus || (DomainStatus = {}));
+export var FieldNamespace;
+(function (FieldNamespace) {
+    FieldNamespace["CUSTOM"] = "Custom";
+    FieldNamespace["SYSTEM"] = "System";
+})(FieldNamespace || (FieldNamespace = {}));
+export var FieldType;
+(function (FieldType) {
+    FieldType["BOOLEAN"] = "Boolean";
+    FieldType["DATE_TIME"] = "DateTime";
+    FieldType["NUMBER"] = "Number";
+    FieldType["SINGLE_SELECT"] = "SingleSelect";
+    FieldType["TEXT"] = "Text";
+})(FieldType || (FieldType = {}));
+export var Section;
+(function (Section) {
+    Section.visit = (value, visitor) => {
+        if (value.fieldGroup !== undefined)
+            return visitor.fieldGroup(value.fieldGroup);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(Section || (Section = {}));
+export var LayoutContent;
+(function (LayoutContent) {
+    LayoutContent.visit = (value, visitor) => {
+        if (value.basic !== undefined)
+            return visitor.basic(value.basic);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(LayoutContent || (LayoutContent = {}));
+export var CaseFilter;
+(function (CaseFilter) {
+    CaseFilter.visit = (value, visitor) => {
+        if (value.field !== undefined)
+            return visitor.field(value.field);
+        if (value.not !== undefined)
+            return visitor.not(value.not);
+        if (value.andAll !== undefined)
+            return visitor.andAll(value.andAll);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CaseFilter || (CaseFilter = {}));
+export const FieldValueUnionFilterSensitiveLog = (obj) => {
+    if (obj.stringValue !== undefined)
+        return { stringValue: obj.stringValue };
+    if (obj.doubleValue !== undefined)
+        return { doubleValue: obj.doubleValue };
+    if (obj.booleanValue !== undefined)
+        return { booleanValue: obj.booleanValue };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const FieldValueFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.value && { value: FieldValueUnionFilterSensitiveLog(obj.value) }),
+});
+export const CreateCaseRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.fields && { fields: obj.fields.map((item) => FieldValueFilterSensitiveLog(item)) }),
+});
+export const CreateCaseResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FieldIdentifierFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetCaseRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetCaseResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.fields && { fields: obj.fields.map((item) => FieldValueFilterSensitiveLog(item)) }),
+});
+export const ListCasesForContactRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CaseSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListCasesForContactResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CommentContentFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ContactFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RelatedItemInputContentFilterSensitiveLog = (obj) => {
+    if (obj.contact !== undefined)
+        return { contact: ContactFilterSensitiveLog(obj.contact) };
+    if (obj.comment !== undefined)
+        return { comment: CommentContentFilterSensitiveLog(obj.comment) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CreateRelatedItemRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: RelatedItemInputContentFilterSensitiveLog(obj.content) }),
+});
+export const CreateRelatedItemResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CommentFilterFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ContactFilterFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RelatedItemTypeFilterFilterSensitiveLog = (obj) => {
+    if (obj.contact !== undefined)
+        return { contact: ContactFilterFilterSensitiveLog(obj.contact) };
+    if (obj.comment !== undefined)
+        return { comment: CommentFilterFilterSensitiveLog(obj.comment) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const SearchRelatedItemsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.filters && { filters: obj.filters.map((item) => RelatedItemTypeFilterFilterSensitiveLog(item)) }),
+});
+export const ContactContentFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RelatedItemContentFilterSensitiveLog = (obj) => {
+    if (obj.contact !== undefined)
+        return { contact: ContactContentFilterSensitiveLog(obj.contact) };
+    if (obj.comment !== undefined)
+        return { comment: CommentContentFilterSensitiveLog(obj.comment) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const SearchRelatedItemsResponseItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: RelatedItemContentFilterSensitiveLog(obj.content) }),
+});
+export const SearchRelatedItemsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.relatedItems && {
+        relatedItems: obj.relatedItems.map((item) => SearchRelatedItemsResponseItemFilterSensitiveLog(item)),
+    }),
+});
+export const FieldFilterFilterSensitiveLog = (obj) => {
+    if (obj.equalTo !== undefined)
+        return { equalTo: FieldValueFilterSensitiveLog(obj.equalTo) };
+    if (obj.contains !== undefined)
+        return { contains: FieldValueFilterSensitiveLog(obj.contains) };
+    if (obj.greaterThan !== undefined)
+        return { greaterThan: FieldValueFilterSensitiveLog(obj.greaterThan) };
+    if (obj.greaterThanOrEqualTo !== undefined)
+        return { greaterThanOrEqualTo: FieldValueFilterSensitiveLog(obj.greaterThanOrEqualTo) };
+    if (obj.lessThan !== undefined)
+        return { lessThan: FieldValueFilterSensitiveLog(obj.lessThan) };
+    if (obj.lessThanOrEqualTo !== undefined)
+        return { lessThanOrEqualTo: FieldValueFilterSensitiveLog(obj.lessThanOrEqualTo) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const SortFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const SearchCasesResponseItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.fields && { fields: obj.fields.map((item) => FieldValueFilterSensitiveLog(item)) }),
+});
+export const SearchCasesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateCaseRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.fields && { fields: obj.fields.map((item) => FieldValueFilterSensitiveLog(item)) }),
+});
+export const UpdateCaseResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateDomainRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateDomainResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetCaseEventConfigurationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CaseEventIncludedDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RelatedItemEventIncludedDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const EventIncludedDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const EventBridgeConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetCaseEventConfigurationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDomainRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDomainResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListDomainsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DomainSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListDomainsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PutCaseEventConfigurationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PutCaseEventConfigurationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const BatchGetFieldRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FieldErrorFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetFieldResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const BatchGetFieldResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FieldOptionFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const BatchPutFieldOptionsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FieldOptionErrorFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const BatchPutFieldOptionsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateFieldRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateFieldResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListFieldOptionsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListFieldOptionsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListFieldsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FieldSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListFieldsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateFieldRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateFieldResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FieldItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FieldGroupFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const SectionFilterSensitiveLog = (obj) => {
+    if (obj.fieldGroup !== undefined)
+        return { fieldGroup: FieldGroupFilterSensitiveLog(obj.fieldGroup) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const LayoutSectionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.sections && { sections: obj.sections.map((item) => SectionFilterSensitiveLog(item)) }),
+});
+export const BasicLayoutFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.topPanel && { topPanel: LayoutSectionsFilterSensitiveLog(obj.topPanel) }),
+    ...(obj.moreInfo && { moreInfo: LayoutSectionsFilterSensitiveLog(obj.moreInfo) }),
+});
+export const LayoutContentFilterSensitiveLog = (obj) => {
+    if (obj.basic !== undefined)
+        return { basic: BasicLayoutFilterSensitiveLog(obj.basic) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CreateLayoutRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: LayoutContentFilterSensitiveLog(obj.content) }),
+});
+export const CreateLayoutResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetLayoutRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetLayoutResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: LayoutContentFilterSensitiveLog(obj.content) }),
+});
+export const ListLayoutsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const LayoutSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListLayoutsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateLayoutRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: LayoutContentFilterSensitiveLog(obj.content) }),
+});
+export const UpdateLayoutResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListTagsForResourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListTagsForResourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const TagResourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const LayoutConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RequiredFieldFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateTemplateRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateTemplateResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetTemplateRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetTemplateResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListTemplatesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const TemplateSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListTemplatesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateTemplateRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateTemplateResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UntagResourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CaseFilterFilterSensitiveLog = (obj) => {
+    if (obj.field !== undefined)
+        return { field: FieldFilterFilterSensitiveLog(obj.field) };
+    if (obj.not !== undefined)
+        return { not: CaseFilterFilterSensitiveLog(obj.not) };
+    if (obj.andAll !== undefined)
+        return { andAll: obj.andAll.map((item) => CaseFilterFilterSensitiveLog(item)) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const SearchCasesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.filter && { filter: CaseFilterFilterSensitiveLog(obj.filter) }),
+});

package/dist-es/pagination/GetCasePaginator.js

@@ -0,0 +1,31 @@
+import { GetCaseCommand } from "../commands/GetCaseCommand";
+import { ConnectCases } from "../ConnectCases";
+import { ConnectCasesClient } from "../ConnectCasesClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetCaseCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.getCase(input, ...args);
+};
+export async function* paginateGetCase(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof ConnectCases) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ConnectCasesClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ConnectCases | ConnectCasesClient");
+        }
+        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/ListCasesForContactPaginator.js

@@ -0,0 +1,32 @@
+import { ListCasesForContactCommand, } from "../commands/ListCasesForContactCommand";
+import { ConnectCases } from "../ConnectCases";
+import { ConnectCasesClient } from "../ConnectCasesClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListCasesForContactCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listCasesForContact(input, ...args);
+};
+export async function* paginateListCasesForContact(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 ConnectCases) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ConnectCasesClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ConnectCases | ConnectCasesClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListDomainsPaginator.js

@@ -0,0 +1,32 @@
+import { ListDomainsCommand } from "../commands/ListDomainsCommand";
+import { ConnectCases } from "../ConnectCases";
+import { ConnectCasesClient } from "../ConnectCasesClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDomainsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listDomains(input, ...args);
+};
+export async function* paginateListDomains(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 ConnectCases) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ConnectCasesClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ConnectCases | ConnectCasesClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListFieldOptionsPaginator.js

@@ -0,0 +1,32 @@
+import { ListFieldOptionsCommand, } from "../commands/ListFieldOptionsCommand";
+import { ConnectCases } from "../ConnectCases";
+import { ConnectCasesClient } from "../ConnectCasesClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListFieldOptionsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listFieldOptions(input, ...args);
+};
+export async function* paginateListFieldOptions(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 ConnectCases) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ConnectCasesClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ConnectCases | ConnectCasesClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}