@aws-sdk/client-connect 3.282.0 → 3.288.0

package/dist-es/models/models_1.js

@@ -1,5 +1,10 @@
 import { SENSITIVE_STRING } from "@aws-sdk/smithy-client";
 import { ConnectServiceException as __BaseException } from "./ConnectServiceException";
+export var ReferenceStatus;
+(function (ReferenceStatus) {
+    ReferenceStatus["APPROVED"] = "APPROVED";
+    ReferenceStatus["REJECTED"] = "REJECTED";
+})(ReferenceStatus || (ReferenceStatus = {}));
 export var ReferenceSummary;
 (function (ReferenceSummary) {
     ReferenceSummary.visit = (value, visitor) => {
@@ -125,6 +130,27 @@ export var UpdateParticipantRoleConfigChannelInfo;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(UpdateParticipantRoleConfigChannelInfo || (UpdateParticipantRoleConfigChannelInfo = {}));
+export const ListContactFlowModulesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ContactFlowModuleSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListContactFlowModulesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListContactFlowsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ContactFlowSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListContactFlowsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListContactReferencesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const AttachmentReferenceFilterSensitiveLog = (obj) => ({
     ...obj,
 });

package/dist-es/pagination/GetCurrentMetricDataPaginator.js

@@ -1,12 +1,8 @@
 import { GetCurrentMetricDataCommand, } from "../commands/GetCurrentMetricDataCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new GetCurrentMetricDataCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.getCurrentMetricData(input, ...args);
-};
 export async function* paginateGetCurrentMetricData(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateGetCurrentMetricData(config, input, ...additional
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/GetCurrentUserDataPaginator.js

@@ -1,12 +1,8 @@
 import { GetCurrentUserDataCommand, } from "../commands/GetCurrentUserDataCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new GetCurrentUserDataCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.getCurrentUserData(input, ...args);
-};
 export async function* paginateGetCurrentUserData(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateGetCurrentUserData(config, input, ...additionalAr
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/GetMetricDataPaginator.js

@@ -1,12 +1,8 @@
 import { GetMetricDataCommand, } from "../commands/GetMetricDataCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new GetMetricDataCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.getMetricData(input, ...args);
-};
 export async function* paginateGetMetricData(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateGetMetricData(config, input, ...additionalArgumen
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/GetMetricDataV2Paginator.js

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

package/dist-es/pagination/ListAgentStatusesPaginator.js

@@ -1,12 +1,8 @@
 import { ListAgentStatusesCommand, } from "../commands/ListAgentStatusesCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListAgentStatusesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listAgentStatuses(input, ...args);
-};
 export async function* paginateListAgentStatuses(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListAgentStatuses(config, input, ...additionalArg
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListApprovedOriginsPaginator.js

@@ -1,12 +1,8 @@
 import { ListApprovedOriginsCommand, } from "../commands/ListApprovedOriginsCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListApprovedOriginsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listApprovedOrigins(input, ...args);
-};
 export async function* paginateListApprovedOrigins(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListApprovedOrigins(config, input, ...additionalA
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListBotsPaginator.js

@@ -1,12 +1,8 @@
 import { ListBotsCommand } from "../commands/ListBotsCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListBotsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listBots(input, ...args);
-};
 export async function* paginateListBots(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListBots(config, input, ...additionalArguments) {
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListContactFlowModulesPaginator.js

@@ -1,12 +1,8 @@
 import { ListContactFlowModulesCommand, } from "../commands/ListContactFlowModulesCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListContactFlowModulesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listContactFlowModules(input, ...args);
-};
 export async function* paginateListContactFlowModules(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListContactFlowModules(config, input, ...addition
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListContactFlowsPaginator.js

@@ -1,12 +1,8 @@
 import { ListContactFlowsCommand, } from "../commands/ListContactFlowsCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListContactFlowsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listContactFlows(input, ...args);
-};
 export async function* paginateListContactFlows(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListContactFlows(config, input, ...additionalArgu
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListContactReferencesPaginator.js

@@ -1,22 +1,15 @@
 import { ListContactReferencesCommand, } from "../commands/ListContactReferencesCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListContactReferencesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listContactReferences(input, ...args);
-};
 export async function* paginateListContactReferences(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.NextToken = token;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListDefaultVocabulariesPaginator.js

@@ -1,12 +1,8 @@
 import { ListDefaultVocabulariesCommand, } from "../commands/ListDefaultVocabulariesCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListDefaultVocabulariesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listDefaultVocabularies(input, ...args);
-};
 export async function* paginateListDefaultVocabularies(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListDefaultVocabularies(config, input, ...additio
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListHoursOfOperationsPaginator.js

@@ -1,12 +1,8 @@
 import { ListHoursOfOperationsCommand, } from "../commands/ListHoursOfOperationsCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListHoursOfOperationsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listHoursOfOperations(input, ...args);
-};
 export async function* paginateListHoursOfOperations(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListHoursOfOperations(config, input, ...additiona
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListInstanceAttributesPaginator.js

@@ -1,12 +1,8 @@
 import { ListInstanceAttributesCommand, } from "../commands/ListInstanceAttributesCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListInstanceAttributesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listInstanceAttributes(input, ...args);
-};
 export async function* paginateListInstanceAttributes(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListInstanceAttributes(config, input, ...addition
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListInstanceStorageConfigsPaginator.js

@@ -1,12 +1,8 @@
 import { ListInstanceStorageConfigsCommand, } from "../commands/ListInstanceStorageConfigsCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListInstanceStorageConfigsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listInstanceStorageConfigs(input, ...args);
-};
 export async function* paginateListInstanceStorageConfigs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListInstanceStorageConfigs(config, input, ...addi
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListInstancesPaginator.js

@@ -1,12 +1,8 @@
 import { ListInstancesCommand, } from "../commands/ListInstancesCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListInstancesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listInstances(input, ...args);
-};
 export async function* paginateListInstances(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListInstances(config, input, ...additionalArgumen
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListIntegrationAssociationsPaginator.js

@@ -1,12 +1,8 @@
 import { ListIntegrationAssociationsCommand, } from "../commands/ListIntegrationAssociationsCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListIntegrationAssociationsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listIntegrationAssociations(input, ...args);
-};
 export async function* paginateListIntegrationAssociations(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListIntegrationAssociations(config, input, ...add
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListLambdaFunctionsPaginator.js

@@ -1,12 +1,8 @@
 import { ListLambdaFunctionsCommand, } from "../commands/ListLambdaFunctionsCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListLambdaFunctionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listLambdaFunctions(input, ...args);
-};
 export async function* paginateListLambdaFunctions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListLambdaFunctions(config, input, ...additionalA
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListLexBotsPaginator.js

@@ -1,12 +1,8 @@
 import { ListLexBotsCommand } from "../commands/ListLexBotsCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListLexBotsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listLexBots(input, ...args);
-};
 export async function* paginateListLexBots(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListLexBots(config, input, ...additionalArguments
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListPhoneNumbersPaginator.js

@@ -1,12 +1,8 @@
 import { ListPhoneNumbersCommand, } from "../commands/ListPhoneNumbersCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListPhoneNumbersCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listPhoneNumbers(input, ...args);
-};
 export async function* paginateListPhoneNumbers(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListPhoneNumbers(config, input, ...additionalArgu
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListPhoneNumbersV2Paginator.js

@@ -1,12 +1,8 @@
 import { ListPhoneNumbersV2Command, } from "../commands/ListPhoneNumbersV2Command";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListPhoneNumbersV2Command(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listPhoneNumbersV2(input, ...args);
-};
 export async function* paginateListPhoneNumbersV2(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListPhoneNumbersV2(config, input, ...additionalAr
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListPromptsPaginator.js

@@ -1,12 +1,8 @@
 import { ListPromptsCommand } from "../commands/ListPromptsCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListPromptsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listPrompts(input, ...args);
-};
 export async function* paginateListPrompts(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListPrompts(config, input, ...additionalArguments
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListQueueQuickConnectsPaginator.js

@@ -1,12 +1,8 @@
 import { ListQueueQuickConnectsCommand, } from "../commands/ListQueueQuickConnectsCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListQueueQuickConnectsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listQueueQuickConnects(input, ...args);
-};
 export async function* paginateListQueueQuickConnects(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListQueueQuickConnects(config, input, ...addition
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListQueuesPaginator.js

@@ -1,12 +1,8 @@
 import { ListQueuesCommand } from "../commands/ListQueuesCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListQueuesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listQueues(input, ...args);
-};
 export async function* paginateListQueues(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListQueues(config, input, ...additionalArguments)
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListQuickConnectsPaginator.js

@@ -1,12 +1,8 @@
 import { ListQuickConnectsCommand, } from "../commands/ListQuickConnectsCommand";
-import { Connect } from "../Connect";
 import { ConnectClient } from "../ConnectClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListQuickConnectsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listQuickConnects(input, ...args);
-};
 export async function* paginateListQuickConnects(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListQuickConnects(config, input, ...additionalArg
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Connect) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ConnectClient) {
+        if (config.client instanceof ConnectClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {