@aws-sdk/client-sagemaker 3.282.0 → 3.287.0

package/dist-es/pagination/ListActionsPaginator.js

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

package/dist-es/pagination/ListAlgorithmsPaginator.js

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

package/dist-es/pagination/ListAliasesPaginator.js

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

package/dist-es/pagination/ListAppImageConfigsPaginator.js

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

package/dist-es/pagination/ListAppsPaginator.js

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

package/dist-es/pagination/ListArtifactsPaginator.js

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

package/dist-es/pagination/ListAssociationsPaginator.js

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

package/dist-es/pagination/ListAutoMLJobsPaginator.js

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

package/dist-es/pagination/ListCandidatesForAutoMLJobPaginator.js

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

package/dist-es/pagination/ListCodeRepositoriesPaginator.js

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

package/dist-es/pagination/ListCompilationJobsPaginator.js

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

package/dist-es/pagination/ListContextsPaginator.js

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

package/dist-es/pagination/ListDataQualityJobDefinitionsPaginator.js

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

package/dist-es/pagination/ListDeviceFleetsPaginator.js

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

package/dist-es/pagination/ListDevicesPaginator.js

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

package/dist-es/pagination/ListDomainsPaginator.js

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

package/dist-es/pagination/ListEdgeDeploymentPlansPaginator.js

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

package/dist-es/pagination/ListEdgePackagingJobsPaginator.js

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

package/dist-es/pagination/ListEndpointConfigsPaginator.js

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

package/dist-es/pagination/ListEndpointsPaginator.js

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

package/dist-es/pagination/ListExperimentsPaginator.js

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

package/dist-es/pagination/ListFlowDefinitionsPaginator.js

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

package/dist-es/pagination/ListHumanTaskUisPaginator.js

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

package/dist-es/pagination/ListHyperParameterTuningJobsPaginator.js

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

package/dist-es/pagination/ListImageVersionsPaginator.js

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