@aws-sdk/client-iot 3.282.0 → 3.287.0

package/dist-es/pagination/ListDimensionsPaginator.js

@@ -1,12 +1,8 @@
 import { ListDimensionsCommand, } from "../commands/ListDimensionsCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListDimensionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listDimensions(input, ...args);
-};
 export async function* paginateListDimensions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListDimensions(config, input, ...additionalArgume
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListDomainConfigurationsPaginator.js

@@ -1,12 +1,8 @@
 import { ListDomainConfigurationsCommand, } from "../commands/ListDomainConfigurationsCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListDomainConfigurationsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listDomainConfigurations(input, ...args);
-};
 export async function* paginateListDomainConfigurations(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListDomainConfigurations(config, input, ...additi
     while (hasNext) {
         input.marker = token;
         input["pageSize"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListFleetMetricsPaginator.js

@@ -1,12 +1,8 @@
 import { ListFleetMetricsCommand, } from "../commands/ListFleetMetricsCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListFleetMetricsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listFleetMetrics(input, ...args);
-};
 export async function* paginateListFleetMetrics(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListFleetMetrics(config, input, ...additionalArgu
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListIndicesPaginator.js

@@ -1,12 +1,8 @@
 import { ListIndicesCommand } from "../commands/ListIndicesCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListIndicesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listIndices(input, ...args);
-};
 export async function* paginateListIndices(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListIndices(config, input, ...additionalArguments
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListJobExecutionsForJobPaginator.js

@@ -1,12 +1,8 @@
 import { ListJobExecutionsForJobCommand, } from "../commands/ListJobExecutionsForJobCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListJobExecutionsForJobCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listJobExecutionsForJob(input, ...args);
-};
 export async function* paginateListJobExecutionsForJob(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListJobExecutionsForJob(config, input, ...additio
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListJobExecutionsForThingPaginator.js

@@ -1,12 +1,8 @@
 import { ListJobExecutionsForThingCommand, } from "../commands/ListJobExecutionsForThingCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListJobExecutionsForThingCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listJobExecutionsForThing(input, ...args);
-};
 export async function* paginateListJobExecutionsForThing(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListJobExecutionsForThing(config, input, ...addit
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListJobTemplatesPaginator.js

@@ -1,12 +1,8 @@
 import { ListJobTemplatesCommand, } from "../commands/ListJobTemplatesCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListJobTemplatesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listJobTemplates(input, ...args);
-};
 export async function* paginateListJobTemplates(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListJobTemplates(config, input, ...additionalArgu
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListJobsPaginator.js

@@ -1,12 +1,8 @@
 import { ListJobsCommand } from "../commands/ListJobsCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListJobsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listJobs(input, ...args);
-};
 export async function* paginateListJobs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListJobs(config, input, ...additionalArguments) {
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListMetricValuesPaginator.js

@@ -1,12 +1,8 @@
 import { ListMetricValuesCommand, } from "../commands/ListMetricValuesCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListMetricValuesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listMetricValues(input, ...args);
-};
 export async function* paginateListMetricValues(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListMetricValues(config, input, ...additionalArgu
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListMitigationActionsPaginator.js

@@ -1,12 +1,8 @@
 import { ListMitigationActionsCommand, } from "../commands/ListMitigationActionsCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListMitigationActionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listMitigationActions(input, ...args);
-};
 export async function* paginateListMitigationActions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListMitigationActions(config, input, ...additiona
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListOTAUpdatesPaginator.js

@@ -1,12 +1,8 @@
 import { ListOTAUpdatesCommand, } from "../commands/ListOTAUpdatesCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListOTAUpdatesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listOTAUpdates(input, ...args);
-};
 export async function* paginateListOTAUpdates(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListOTAUpdates(config, input, ...additionalArgume
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListOutgoingCertificatesPaginator.js

@@ -1,12 +1,8 @@
 import { ListOutgoingCertificatesCommand, } from "../commands/ListOutgoingCertificatesCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListOutgoingCertificatesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listOutgoingCertificates(input, ...args);
-};
 export async function* paginateListOutgoingCertificates(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListOutgoingCertificates(config, input, ...additi
     while (hasNext) {
         input.marker = token;
         input["pageSize"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListPoliciesPaginator.js

@@ -1,12 +1,8 @@
 import { ListPoliciesCommand, } from "../commands/ListPoliciesCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListPoliciesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listPolicies(input, ...args);
-};
 export async function* paginateListPolicies(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListPolicies(config, input, ...additionalArgument
     while (hasNext) {
         input.marker = token;
         input["pageSize"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListPolicyPrincipalsPaginator.js

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

package/dist-es/pagination/ListPrincipalPoliciesPaginator.js

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

package/dist-es/pagination/ListPrincipalThingsPaginator.js

@@ -1,12 +1,8 @@
 import { ListPrincipalThingsCommand, } from "../commands/ListPrincipalThingsCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListPrincipalThingsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listPrincipalThings(input, ...args);
-};
 export async function* paginateListPrincipalThings(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListPrincipalThings(config, input, ...additionalA
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListProvisioningTemplateVersionsPaginator.js

@@ -1,12 +1,8 @@
 import { ListProvisioningTemplateVersionsCommand, } from "../commands/ListProvisioningTemplateVersionsCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListProvisioningTemplateVersionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listProvisioningTemplateVersions(input, ...args);
-};
 export async function* paginateListProvisioningTemplateVersions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListProvisioningTemplateVersions(config, input, .
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListProvisioningTemplatesPaginator.js

@@ -1,12 +1,8 @@
 import { ListProvisioningTemplatesCommand, } from "../commands/ListProvisioningTemplatesCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListProvisioningTemplatesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listProvisioningTemplates(input, ...args);
-};
 export async function* paginateListProvisioningTemplates(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListProvisioningTemplates(config, input, ...addit
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListRoleAliasesPaginator.js

@@ -1,12 +1,8 @@
 import { ListRoleAliasesCommand, } from "../commands/ListRoleAliasesCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListRoleAliasesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listRoleAliases(input, ...args);
-};
 export async function* paginateListRoleAliases(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListRoleAliases(config, input, ...additionalArgum
     while (hasNext) {
         input.marker = token;
         input["pageSize"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListScheduledAuditsPaginator.js

@@ -1,12 +1,8 @@
 import { ListScheduledAuditsCommand, } from "../commands/ListScheduledAuditsCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListScheduledAuditsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listScheduledAudits(input, ...args);
-};
 export async function* paginateListScheduledAudits(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListScheduledAudits(config, input, ...additionalA
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListSecurityProfilesForTargetPaginator.js

@@ -1,12 +1,8 @@
 import { ListSecurityProfilesForTargetCommand, } from "../commands/ListSecurityProfilesForTargetCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListSecurityProfilesForTargetCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listSecurityProfilesForTarget(input, ...args);
-};
 export async function* paginateListSecurityProfilesForTarget(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListSecurityProfilesForTarget(config, input, ...a
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListSecurityProfilesPaginator.js

@@ -1,12 +1,8 @@
 import { ListSecurityProfilesCommand, } from "../commands/ListSecurityProfilesCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListSecurityProfilesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listSecurityProfiles(input, ...args);
-};
 export async function* paginateListSecurityProfiles(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListSecurityProfiles(config, input, ...additional
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListStreamsPaginator.js

@@ -1,12 +1,8 @@
 import { ListStreamsCommand } from "../commands/ListStreamsCommand";
-import { IoT } from "../IoT";
 import { IoTClient } from "../IoTClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListStreamsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listStreams(input, ...args);
-};
 export async function* paginateListStreams(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListStreams(config, input, ...additionalArguments
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof IoT) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IoTClient) {
+        if (config.client instanceof IoTClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListTagsForResourcePaginator.js

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

package/dist-es/pagination/ListTargetsForPolicyPaginator.js

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