@aws-sdk/client-glue 3.281.0 → 3.287.0

package/dist-es/pagination/GetMLTaskRunsPaginator.js

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

package/dist-es/pagination/GetMLTransformsPaginator.js

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

package/dist-es/pagination/GetPartitionIndexesPaginator.js

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

package/dist-es/pagination/GetPartitionsPaginator.js

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

package/dist-es/pagination/GetResourcePoliciesPaginator.js

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

package/dist-es/pagination/GetSecurityConfigurationsPaginator.js

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

package/dist-es/pagination/GetTableVersionsPaginator.js

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

package/dist-es/pagination/GetTablesPaginator.js

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

package/dist-es/pagination/GetTriggersPaginator.js

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

package/dist-es/pagination/GetUnfilteredPartitionsMetadataPaginator.js

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

package/dist-es/pagination/GetUserDefinedFunctionsPaginator.js

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

package/dist-es/pagination/GetWorkflowRunsPaginator.js

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

package/dist-es/pagination/ListBlueprintsPaginator.js

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

package/dist-es/pagination/ListCrawlersPaginator.js

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

package/dist-es/pagination/ListCustomEntityTypesPaginator.js

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

package/dist-es/pagination/ListDataQualityResultsPaginator.js

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

package/dist-es/pagination/ListDataQualityRuleRecommendationRunsPaginator.js

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

package/dist-es/pagination/ListDataQualityRulesetEvaluationRunsPaginator.js

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

package/dist-es/pagination/ListDataQualityRulesetsPaginator.js

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

package/dist-es/pagination/ListDevEndpointsPaginator.js

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

package/dist-es/pagination/ListJobsPaginator.js

@@ -1,12 +1,8 @@
 import { ListJobsCommand } from "../commands/ListJobsCommand";
-import { Glue } from "../Glue";
 import { GlueClient } from "../GlueClient";
 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 Glue) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof GlueClient) {
+        if (config.client instanceof GlueClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListMLTransformsPaginator.js

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

package/dist-es/pagination/ListRegistriesPaginator.js

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

package/dist-es/pagination/ListSchemaVersionsPaginator.js

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

package/dist-es/pagination/ListSchemasPaginator.js

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