@aws-sdk/client-config-service 3.282.0 → 3.288.0

package/dist-es/pagination/DescribeConfigRulesPaginator.js

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

package/dist-es/pagination/DescribeConfigurationAggregatorSourcesStatusPaginator.js

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

package/dist-es/pagination/DescribeConfigurationAggregatorsPaginator.js

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

package/dist-es/pagination/DescribeConformancePackCompliancePaginator.js

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

package/dist-es/pagination/DescribeConformancePackStatusPaginator.js

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

package/dist-es/pagination/DescribeConformancePacksPaginator.js

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

package/dist-es/pagination/DescribeOrganizationConfigRuleStatusesPaginator.js

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

package/dist-es/pagination/DescribeOrganizationConfigRulesPaginator.js

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

package/dist-es/pagination/DescribeOrganizationConformancePackStatusesPaginator.js

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

package/dist-es/pagination/DescribeOrganizationConformancePacksPaginator.js

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

package/dist-es/pagination/DescribePendingAggregationRequestsPaginator.js

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

package/dist-es/pagination/DescribeRemediationExceptionsPaginator.js

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

package/dist-es/pagination/DescribeRemediationExecutionStatusPaginator.js

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

package/dist-es/pagination/DescribeRetentionConfigurationsPaginator.js

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

package/dist-es/pagination/GetAggregateComplianceDetailsByConfigRulePaginator.js

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

package/dist-es/pagination/GetAggregateConfigRuleComplianceSummaryPaginator.js

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

package/dist-es/pagination/GetAggregateConformancePackComplianceSummaryPaginator.js

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

package/dist-es/pagination/GetAggregateDiscoveredResourceCountsPaginator.js

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

package/dist-es/pagination/GetComplianceDetailsByConfigRulePaginator.js

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

package/dist-es/pagination/GetComplianceDetailsByResourcePaginator.js

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

package/dist-es/pagination/GetConformancePackComplianceDetailsPaginator.js

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

package/dist-es/pagination/GetConformancePackComplianceSummaryPaginator.js

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

package/dist-es/pagination/GetDiscoveredResourceCountsPaginator.js

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

package/dist-es/pagination/GetOrganizationConfigRuleDetailedStatusPaginator.js

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

package/dist-es/pagination/GetOrganizationConformancePackDetailedStatusPaginator.js

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