@aws-sdk/client-sagemaker 3.183.0 → 3.185.0

package/dist-es/SageMaker.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { AddAssociationCommand, } from "./commands/AddAssociationCommand";
 import { AddTagsCommand } from "./commands/AddTagsCommand";
 import { AssociateTrialComponentCommand, } from "./commands/AssociateTrialComponentCommand";
@@ -262,3687 +263,3693 @@ import { UpdateUserProfileCommand, } from "./commands/UpdateUserProfileCommand";
 import { UpdateWorkforceCommand, } from "./commands/UpdateWorkforceCommand";
 import { UpdateWorkteamCommand, } from "./commands/UpdateWorkteamCommand";
 import { SageMakerClient } from "./SageMakerClient";
-export class SageMaker extends SageMakerClient {
-    addAssociation(args, optionsOrCb, cb) {
-        const command = new AddAssociationCommand(args);
+var SageMaker = (function (_super) {
+    __extends(SageMaker, _super);
+    function SageMaker() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SageMaker.prototype.addAssociation = function (args, optionsOrCb, cb) {
+        var command = new AddAssociationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    addTags(args, optionsOrCb, cb) {
-        const command = new AddTagsCommand(args);
+    };
+    SageMaker.prototype.addTags = function (args, optionsOrCb, cb) {
+        var command = new AddTagsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    associateTrialComponent(args, optionsOrCb, cb) {
-        const command = new AssociateTrialComponentCommand(args);
+    };
+    SageMaker.prototype.associateTrialComponent = function (args, optionsOrCb, cb) {
+        var command = new AssociateTrialComponentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchDescribeModelPackage(args, optionsOrCb, cb) {
-        const command = new BatchDescribeModelPackageCommand(args);
+    };
+    SageMaker.prototype.batchDescribeModelPackage = function (args, optionsOrCb, cb) {
+        var command = new BatchDescribeModelPackageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createAction(args, optionsOrCb, cb) {
-        const command = new CreateActionCommand(args);
+    };
+    SageMaker.prototype.createAction = function (args, optionsOrCb, cb) {
+        var command = new CreateActionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createAlgorithm(args, optionsOrCb, cb) {
-        const command = new CreateAlgorithmCommand(args);
+    };
+    SageMaker.prototype.createAlgorithm = function (args, optionsOrCb, cb) {
+        var command = new CreateAlgorithmCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createApp(args, optionsOrCb, cb) {
-        const command = new CreateAppCommand(args);
+    };
+    SageMaker.prototype.createApp = function (args, optionsOrCb, cb) {
+        var command = new CreateAppCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createAppImageConfig(args, optionsOrCb, cb) {
-        const command = new CreateAppImageConfigCommand(args);
+    };
+    SageMaker.prototype.createAppImageConfig = function (args, optionsOrCb, cb) {
+        var command = new CreateAppImageConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createArtifact(args, optionsOrCb, cb) {
-        const command = new CreateArtifactCommand(args);
+    };
+    SageMaker.prototype.createArtifact = function (args, optionsOrCb, cb) {
+        var command = new CreateArtifactCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createAutoMLJob(args, optionsOrCb, cb) {
-        const command = new CreateAutoMLJobCommand(args);
+    };
+    SageMaker.prototype.createAutoMLJob = function (args, optionsOrCb, cb) {
+        var command = new CreateAutoMLJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createCodeRepository(args, optionsOrCb, cb) {
-        const command = new CreateCodeRepositoryCommand(args);
+    };
+    SageMaker.prototype.createCodeRepository = function (args, optionsOrCb, cb) {
+        var command = new CreateCodeRepositoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createCompilationJob(args, optionsOrCb, cb) {
-        const command = new CreateCompilationJobCommand(args);
+    };
+    SageMaker.prototype.createCompilationJob = function (args, optionsOrCb, cb) {
+        var command = new CreateCompilationJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createContext(args, optionsOrCb, cb) {
-        const command = new CreateContextCommand(args);
+    };
+    SageMaker.prototype.createContext = function (args, optionsOrCb, cb) {
+        var command = new CreateContextCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDataQualityJobDefinition(args, optionsOrCb, cb) {
-        const command = new CreateDataQualityJobDefinitionCommand(args);
+    };
+    SageMaker.prototype.createDataQualityJobDefinition = function (args, optionsOrCb, cb) {
+        var command = new CreateDataQualityJobDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDeviceFleet(args, optionsOrCb, cb) {
-        const command = new CreateDeviceFleetCommand(args);
+    };
+    SageMaker.prototype.createDeviceFleet = function (args, optionsOrCb, cb) {
+        var command = new CreateDeviceFleetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDomain(args, optionsOrCb, cb) {
-        const command = new CreateDomainCommand(args);
+    };
+    SageMaker.prototype.createDomain = function (args, optionsOrCb, cb) {
+        var command = new CreateDomainCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createEdgeDeploymentPlan(args, optionsOrCb, cb) {
-        const command = new CreateEdgeDeploymentPlanCommand(args);
+    };
+    SageMaker.prototype.createEdgeDeploymentPlan = function (args, optionsOrCb, cb) {
+        var command = new CreateEdgeDeploymentPlanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createEdgeDeploymentStage(args, optionsOrCb, cb) {
-        const command = new CreateEdgeDeploymentStageCommand(args);
+    };
+    SageMaker.prototype.createEdgeDeploymentStage = function (args, optionsOrCb, cb) {
+        var command = new CreateEdgeDeploymentStageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createEdgePackagingJob(args, optionsOrCb, cb) {
-        const command = new CreateEdgePackagingJobCommand(args);
+    };
+    SageMaker.prototype.createEdgePackagingJob = function (args, optionsOrCb, cb) {
+        var command = new CreateEdgePackagingJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createEndpoint(args, optionsOrCb, cb) {
-        const command = new CreateEndpointCommand(args);
+    };
+    SageMaker.prototype.createEndpoint = function (args, optionsOrCb, cb) {
+        var command = new CreateEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createEndpointConfig(args, optionsOrCb, cb) {
-        const command = new CreateEndpointConfigCommand(args);
+    };
+    SageMaker.prototype.createEndpointConfig = function (args, optionsOrCb, cb) {
+        var command = new CreateEndpointConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createExperiment(args, optionsOrCb, cb) {
-        const command = new CreateExperimentCommand(args);
+    };
+    SageMaker.prototype.createExperiment = function (args, optionsOrCb, cb) {
+        var command = new CreateExperimentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createFeatureGroup(args, optionsOrCb, cb) {
-        const command = new CreateFeatureGroupCommand(args);
+    };
+    SageMaker.prototype.createFeatureGroup = function (args, optionsOrCb, cb) {
+        var command = new CreateFeatureGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createFlowDefinition(args, optionsOrCb, cb) {
-        const command = new CreateFlowDefinitionCommand(args);
+    };
+    SageMaker.prototype.createFlowDefinition = function (args, optionsOrCb, cb) {
+        var command = new CreateFlowDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createHumanTaskUi(args, optionsOrCb, cb) {
-        const command = new CreateHumanTaskUiCommand(args);
+    };
+    SageMaker.prototype.createHumanTaskUi = function (args, optionsOrCb, cb) {
+        var command = new CreateHumanTaskUiCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createHyperParameterTuningJob(args, optionsOrCb, cb) {
-        const command = new CreateHyperParameterTuningJobCommand(args);
+    };
+    SageMaker.prototype.createHyperParameterTuningJob = function (args, optionsOrCb, cb) {
+        var command = new CreateHyperParameterTuningJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createImage(args, optionsOrCb, cb) {
-        const command = new CreateImageCommand(args);
+    };
+    SageMaker.prototype.createImage = function (args, optionsOrCb, cb) {
+        var command = new CreateImageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createImageVersion(args, optionsOrCb, cb) {
-        const command = new CreateImageVersionCommand(args);
+    };
+    SageMaker.prototype.createImageVersion = function (args, optionsOrCb, cb) {
+        var command = new CreateImageVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createInferenceRecommendationsJob(args, optionsOrCb, cb) {
-        const command = new CreateInferenceRecommendationsJobCommand(args);
+    };
+    SageMaker.prototype.createInferenceRecommendationsJob = function (args, optionsOrCb, cb) {
+        var command = new CreateInferenceRecommendationsJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createLabelingJob(args, optionsOrCb, cb) {
-        const command = new CreateLabelingJobCommand(args);
+    };
+    SageMaker.prototype.createLabelingJob = function (args, optionsOrCb, cb) {
+        var command = new CreateLabelingJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createModel(args, optionsOrCb, cb) {
-        const command = new CreateModelCommand(args);
+    };
+    SageMaker.prototype.createModel = function (args, optionsOrCb, cb) {
+        var command = new CreateModelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createModelBiasJobDefinition(args, optionsOrCb, cb) {
-        const command = new CreateModelBiasJobDefinitionCommand(args);
+    };
+    SageMaker.prototype.createModelBiasJobDefinition = function (args, optionsOrCb, cb) {
+        var command = new CreateModelBiasJobDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createModelExplainabilityJobDefinition(args, optionsOrCb, cb) {
-        const command = new CreateModelExplainabilityJobDefinitionCommand(args);
+    };
+    SageMaker.prototype.createModelExplainabilityJobDefinition = function (args, optionsOrCb, cb) {
+        var command = new CreateModelExplainabilityJobDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createModelPackage(args, optionsOrCb, cb) {
-        const command = new CreateModelPackageCommand(args);
+    };
+    SageMaker.prototype.createModelPackage = function (args, optionsOrCb, cb) {
+        var command = new CreateModelPackageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createModelPackageGroup(args, optionsOrCb, cb) {
-        const command = new CreateModelPackageGroupCommand(args);
+    };
+    SageMaker.prototype.createModelPackageGroup = function (args, optionsOrCb, cb) {
+        var command = new CreateModelPackageGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createModelQualityJobDefinition(args, optionsOrCb, cb) {
-        const command = new CreateModelQualityJobDefinitionCommand(args);
+    };
+    SageMaker.prototype.createModelQualityJobDefinition = function (args, optionsOrCb, cb) {
+        var command = new CreateModelQualityJobDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createMonitoringSchedule(args, optionsOrCb, cb) {
-        const command = new CreateMonitoringScheduleCommand(args);
+    };
+    SageMaker.prototype.createMonitoringSchedule = function (args, optionsOrCb, cb) {
+        var command = new CreateMonitoringScheduleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createNotebookInstance(args, optionsOrCb, cb) {
-        const command = new CreateNotebookInstanceCommand(args);
+    };
+    SageMaker.prototype.createNotebookInstance = function (args, optionsOrCb, cb) {
+        var command = new CreateNotebookInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createNotebookInstanceLifecycleConfig(args, optionsOrCb, cb) {
-        const command = new CreateNotebookInstanceLifecycleConfigCommand(args);
+    };
+    SageMaker.prototype.createNotebookInstanceLifecycleConfig = function (args, optionsOrCb, cb) {
+        var command = new CreateNotebookInstanceLifecycleConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createPipeline(args, optionsOrCb, cb) {
-        const command = new CreatePipelineCommand(args);
+    };
+    SageMaker.prototype.createPipeline = function (args, optionsOrCb, cb) {
+        var command = new CreatePipelineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createPresignedDomainUrl(args, optionsOrCb, cb) {
-        const command = new CreatePresignedDomainUrlCommand(args);
+    };
+    SageMaker.prototype.createPresignedDomainUrl = function (args, optionsOrCb, cb) {
+        var command = new CreatePresignedDomainUrlCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createPresignedNotebookInstanceUrl(args, optionsOrCb, cb) {
-        const command = new CreatePresignedNotebookInstanceUrlCommand(args);
+    };
+    SageMaker.prototype.createPresignedNotebookInstanceUrl = function (args, optionsOrCb, cb) {
+        var command = new CreatePresignedNotebookInstanceUrlCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createProcessingJob(args, optionsOrCb, cb) {
-        const command = new CreateProcessingJobCommand(args);
+    };
+    SageMaker.prototype.createProcessingJob = function (args, optionsOrCb, cb) {
+        var command = new CreateProcessingJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createProject(args, optionsOrCb, cb) {
-        const command = new CreateProjectCommand(args);
+    };
+    SageMaker.prototype.createProject = function (args, optionsOrCb, cb) {
+        var command = new CreateProjectCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createStudioLifecycleConfig(args, optionsOrCb, cb) {
-        const command = new CreateStudioLifecycleConfigCommand(args);
+    };
+    SageMaker.prototype.createStudioLifecycleConfig = function (args, optionsOrCb, cb) {
+        var command = new CreateStudioLifecycleConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createTrainingJob(args, optionsOrCb, cb) {
-        const command = new CreateTrainingJobCommand(args);
+    };
+    SageMaker.prototype.createTrainingJob = function (args, optionsOrCb, cb) {
+        var command = new CreateTrainingJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createTransformJob(args, optionsOrCb, cb) {
-        const command = new CreateTransformJobCommand(args);
+    };
+    SageMaker.prototype.createTransformJob = function (args, optionsOrCb, cb) {
+        var command = new CreateTransformJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createTrial(args, optionsOrCb, cb) {
-        const command = new CreateTrialCommand(args);
+    };
+    SageMaker.prototype.createTrial = function (args, optionsOrCb, cb) {
+        var command = new CreateTrialCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createTrialComponent(args, optionsOrCb, cb) {
-        const command = new CreateTrialComponentCommand(args);
+    };
+    SageMaker.prototype.createTrialComponent = function (args, optionsOrCb, cb) {
+        var command = new CreateTrialComponentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createUserProfile(args, optionsOrCb, cb) {
-        const command = new CreateUserProfileCommand(args);
+    };
+    SageMaker.prototype.createUserProfile = function (args, optionsOrCb, cb) {
+        var command = new CreateUserProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createWorkforce(args, optionsOrCb, cb) {
-        const command = new CreateWorkforceCommand(args);
+    };
+    SageMaker.prototype.createWorkforce = function (args, optionsOrCb, cb) {
+        var command = new CreateWorkforceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createWorkteam(args, optionsOrCb, cb) {
-        const command = new CreateWorkteamCommand(args);
+    };
+    SageMaker.prototype.createWorkteam = function (args, optionsOrCb, cb) {
+        var command = new CreateWorkteamCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteAction(args, optionsOrCb, cb) {
-        const command = new DeleteActionCommand(args);
+    };
+    SageMaker.prototype.deleteAction = function (args, optionsOrCb, cb) {
+        var command = new DeleteActionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteAlgorithm(args, optionsOrCb, cb) {
-        const command = new DeleteAlgorithmCommand(args);
+    };
+    SageMaker.prototype.deleteAlgorithm = function (args, optionsOrCb, cb) {
+        var command = new DeleteAlgorithmCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteApp(args, optionsOrCb, cb) {
-        const command = new DeleteAppCommand(args);
+    };
+    SageMaker.prototype.deleteApp = function (args, optionsOrCb, cb) {
+        var command = new DeleteAppCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteAppImageConfig(args, optionsOrCb, cb) {
-        const command = new DeleteAppImageConfigCommand(args);
+    };
+    SageMaker.prototype.deleteAppImageConfig = function (args, optionsOrCb, cb) {
+        var command = new DeleteAppImageConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteArtifact(args, optionsOrCb, cb) {
-        const command = new DeleteArtifactCommand(args);
+    };
+    SageMaker.prototype.deleteArtifact = function (args, optionsOrCb, cb) {
+        var command = new DeleteArtifactCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteAssociation(args, optionsOrCb, cb) {
-        const command = new DeleteAssociationCommand(args);
+    };
+    SageMaker.prototype.deleteAssociation = function (args, optionsOrCb, cb) {
+        var command = new DeleteAssociationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteCodeRepository(args, optionsOrCb, cb) {
-        const command = new DeleteCodeRepositoryCommand(args);
+    };
+    SageMaker.prototype.deleteCodeRepository = function (args, optionsOrCb, cb) {
+        var command = new DeleteCodeRepositoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteContext(args, optionsOrCb, cb) {
-        const command = new DeleteContextCommand(args);
+    };
+    SageMaker.prototype.deleteContext = function (args, optionsOrCb, cb) {
+        var command = new DeleteContextCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDataQualityJobDefinition(args, optionsOrCb, cb) {
-        const command = new DeleteDataQualityJobDefinitionCommand(args);
+    };
+    SageMaker.prototype.deleteDataQualityJobDefinition = function (args, optionsOrCb, cb) {
+        var command = new DeleteDataQualityJobDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDeviceFleet(args, optionsOrCb, cb) {
-        const command = new DeleteDeviceFleetCommand(args);
+    };
+    SageMaker.prototype.deleteDeviceFleet = function (args, optionsOrCb, cb) {
+        var command = new DeleteDeviceFleetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDomain(args, optionsOrCb, cb) {
-        const command = new DeleteDomainCommand(args);
+    };
+    SageMaker.prototype.deleteDomain = function (args, optionsOrCb, cb) {
+        var command = new DeleteDomainCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteEdgeDeploymentPlan(args, optionsOrCb, cb) {
-        const command = new DeleteEdgeDeploymentPlanCommand(args);
+    };
+    SageMaker.prototype.deleteEdgeDeploymentPlan = function (args, optionsOrCb, cb) {
+        var command = new DeleteEdgeDeploymentPlanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteEdgeDeploymentStage(args, optionsOrCb, cb) {
-        const command = new DeleteEdgeDeploymentStageCommand(args);
+    };
+    SageMaker.prototype.deleteEdgeDeploymentStage = function (args, optionsOrCb, cb) {
+        var command = new DeleteEdgeDeploymentStageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteEndpoint(args, optionsOrCb, cb) {
-        const command = new DeleteEndpointCommand(args);
+    };
+    SageMaker.prototype.deleteEndpoint = function (args, optionsOrCb, cb) {
+        var command = new DeleteEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteEndpointConfig(args, optionsOrCb, cb) {
-        const command = new DeleteEndpointConfigCommand(args);
+    };
+    SageMaker.prototype.deleteEndpointConfig = function (args, optionsOrCb, cb) {
+        var command = new DeleteEndpointConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteExperiment(args, optionsOrCb, cb) {
-        const command = new DeleteExperimentCommand(args);
+    };
+    SageMaker.prototype.deleteExperiment = function (args, optionsOrCb, cb) {
+        var command = new DeleteExperimentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteFeatureGroup(args, optionsOrCb, cb) {
-        const command = new DeleteFeatureGroupCommand(args);
+    };
+    SageMaker.prototype.deleteFeatureGroup = function (args, optionsOrCb, cb) {
+        var command = new DeleteFeatureGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteFlowDefinition(args, optionsOrCb, cb) {
-        const command = new DeleteFlowDefinitionCommand(args);
+    };
+    SageMaker.prototype.deleteFlowDefinition = function (args, optionsOrCb, cb) {
+        var command = new DeleteFlowDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteHumanTaskUi(args, optionsOrCb, cb) {
-        const command = new DeleteHumanTaskUiCommand(args);
+    };
+    SageMaker.prototype.deleteHumanTaskUi = function (args, optionsOrCb, cb) {
+        var command = new DeleteHumanTaskUiCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteImage(args, optionsOrCb, cb) {
-        const command = new DeleteImageCommand(args);
+    };
+    SageMaker.prototype.deleteImage = function (args, optionsOrCb, cb) {
+        var command = new DeleteImageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteImageVersion(args, optionsOrCb, cb) {
-        const command = new DeleteImageVersionCommand(args);
+    };
+    SageMaker.prototype.deleteImageVersion = function (args, optionsOrCb, cb) {
+        var command = new DeleteImageVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteModel(args, optionsOrCb, cb) {
-        const command = new DeleteModelCommand(args);
+    };
+    SageMaker.prototype.deleteModel = function (args, optionsOrCb, cb) {
+        var command = new DeleteModelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteModelBiasJobDefinition(args, optionsOrCb, cb) {
-        const command = new DeleteModelBiasJobDefinitionCommand(args);
+    };
+    SageMaker.prototype.deleteModelBiasJobDefinition = function (args, optionsOrCb, cb) {
+        var command = new DeleteModelBiasJobDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteModelExplainabilityJobDefinition(args, optionsOrCb, cb) {
-        const command = new DeleteModelExplainabilityJobDefinitionCommand(args);
+    };
+    SageMaker.prototype.deleteModelExplainabilityJobDefinition = function (args, optionsOrCb, cb) {
+        var command = new DeleteModelExplainabilityJobDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteModelPackage(args, optionsOrCb, cb) {
-        const command = new DeleteModelPackageCommand(args);
+    };
+    SageMaker.prototype.deleteModelPackage = function (args, optionsOrCb, cb) {
+        var command = new DeleteModelPackageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteModelPackageGroup(args, optionsOrCb, cb) {
-        const command = new DeleteModelPackageGroupCommand(args);
+    };
+    SageMaker.prototype.deleteModelPackageGroup = function (args, optionsOrCb, cb) {
+        var command = new DeleteModelPackageGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteModelPackageGroupPolicy(args, optionsOrCb, cb) {
-        const command = new DeleteModelPackageGroupPolicyCommand(args);
+    };
+    SageMaker.prototype.deleteModelPackageGroupPolicy = function (args, optionsOrCb, cb) {
+        var command = new DeleteModelPackageGroupPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteModelQualityJobDefinition(args, optionsOrCb, cb) {
-        const command = new DeleteModelQualityJobDefinitionCommand(args);
+    };
+    SageMaker.prototype.deleteModelQualityJobDefinition = function (args, optionsOrCb, cb) {
+        var command = new DeleteModelQualityJobDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteMonitoringSchedule(args, optionsOrCb, cb) {
-        const command = new DeleteMonitoringScheduleCommand(args);
+    };
+    SageMaker.prototype.deleteMonitoringSchedule = function (args, optionsOrCb, cb) {
+        var command = new DeleteMonitoringScheduleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteNotebookInstance(args, optionsOrCb, cb) {
-        const command = new DeleteNotebookInstanceCommand(args);
+    };
+    SageMaker.prototype.deleteNotebookInstance = function (args, optionsOrCb, cb) {
+        var command = new DeleteNotebookInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteNotebookInstanceLifecycleConfig(args, optionsOrCb, cb) {
-        const command = new DeleteNotebookInstanceLifecycleConfigCommand(args);
+    };
+    SageMaker.prototype.deleteNotebookInstanceLifecycleConfig = function (args, optionsOrCb, cb) {
+        var command = new DeleteNotebookInstanceLifecycleConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deletePipeline(args, optionsOrCb, cb) {
-        const command = new DeletePipelineCommand(args);
+    };
+    SageMaker.prototype.deletePipeline = function (args, optionsOrCb, cb) {
+        var command = new DeletePipelineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteProject(args, optionsOrCb, cb) {
-        const command = new DeleteProjectCommand(args);
+    };
+    SageMaker.prototype.deleteProject = function (args, optionsOrCb, cb) {
+        var command = new DeleteProjectCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteStudioLifecycleConfig(args, optionsOrCb, cb) {
-        const command = new DeleteStudioLifecycleConfigCommand(args);
+    };
+    SageMaker.prototype.deleteStudioLifecycleConfig = function (args, optionsOrCb, cb) {
+        var command = new DeleteStudioLifecycleConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteTags(args, optionsOrCb, cb) {
-        const command = new DeleteTagsCommand(args);
+    };
+    SageMaker.prototype.deleteTags = function (args, optionsOrCb, cb) {
+        var command = new DeleteTagsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteTrial(args, optionsOrCb, cb) {
-        const command = new DeleteTrialCommand(args);
+    };
+    SageMaker.prototype.deleteTrial = function (args, optionsOrCb, cb) {
+        var command = new DeleteTrialCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteTrialComponent(args, optionsOrCb, cb) {
-        const command = new DeleteTrialComponentCommand(args);
+    };
+    SageMaker.prototype.deleteTrialComponent = function (args, optionsOrCb, cb) {
+        var command = new DeleteTrialComponentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteUserProfile(args, optionsOrCb, cb) {
-        const command = new DeleteUserProfileCommand(args);
+    };
+    SageMaker.prototype.deleteUserProfile = function (args, optionsOrCb, cb) {
+        var command = new DeleteUserProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteWorkforce(args, optionsOrCb, cb) {
-        const command = new DeleteWorkforceCommand(args);
+    };
+    SageMaker.prototype.deleteWorkforce = function (args, optionsOrCb, cb) {
+        var command = new DeleteWorkforceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteWorkteam(args, optionsOrCb, cb) {
-        const command = new DeleteWorkteamCommand(args);
+    };
+    SageMaker.prototype.deleteWorkteam = function (args, optionsOrCb, cb) {
+        var command = new DeleteWorkteamCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deregisterDevices(args, optionsOrCb, cb) {
-        const command = new DeregisterDevicesCommand(args);
+    };
+    SageMaker.prototype.deregisterDevices = function (args, optionsOrCb, cb) {
+        var command = new DeregisterDevicesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAction(args, optionsOrCb, cb) {
-        const command = new DescribeActionCommand(args);
+    };
+    SageMaker.prototype.describeAction = function (args, optionsOrCb, cb) {
+        var command = new DescribeActionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAlgorithm(args, optionsOrCb, cb) {
-        const command = new DescribeAlgorithmCommand(args);
+    };
+    SageMaker.prototype.describeAlgorithm = function (args, optionsOrCb, cb) {
+        var command = new DescribeAlgorithmCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeApp(args, optionsOrCb, cb) {
-        const command = new DescribeAppCommand(args);
+    };
+    SageMaker.prototype.describeApp = function (args, optionsOrCb, cb) {
+        var command = new DescribeAppCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAppImageConfig(args, optionsOrCb, cb) {
-        const command = new DescribeAppImageConfigCommand(args);
+    };
+    SageMaker.prototype.describeAppImageConfig = function (args, optionsOrCb, cb) {
+        var command = new DescribeAppImageConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeArtifact(args, optionsOrCb, cb) {
-        const command = new DescribeArtifactCommand(args);
+    };
+    SageMaker.prototype.describeArtifact = function (args, optionsOrCb, cb) {
+        var command = new DescribeArtifactCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAutoMLJob(args, optionsOrCb, cb) {
-        const command = new DescribeAutoMLJobCommand(args);
+    };
+    SageMaker.prototype.describeAutoMLJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeAutoMLJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeCodeRepository(args, optionsOrCb, cb) {
-        const command = new DescribeCodeRepositoryCommand(args);
+    };
+    SageMaker.prototype.describeCodeRepository = function (args, optionsOrCb, cb) {
+        var command = new DescribeCodeRepositoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeCompilationJob(args, optionsOrCb, cb) {
-        const command = new DescribeCompilationJobCommand(args);
+    };
+    SageMaker.prototype.describeCompilationJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeCompilationJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeContext(args, optionsOrCb, cb) {
-        const command = new DescribeContextCommand(args);
+    };
+    SageMaker.prototype.describeContext = function (args, optionsOrCb, cb) {
+        var command = new DescribeContextCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeDataQualityJobDefinition(args, optionsOrCb, cb) {
-        const command = new DescribeDataQualityJobDefinitionCommand(args);
+    };
+    SageMaker.prototype.describeDataQualityJobDefinition = function (args, optionsOrCb, cb) {
+        var command = new DescribeDataQualityJobDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeDevice(args, optionsOrCb, cb) {
-        const command = new DescribeDeviceCommand(args);
+    };
+    SageMaker.prototype.describeDevice = function (args, optionsOrCb, cb) {
+        var command = new DescribeDeviceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeDeviceFleet(args, optionsOrCb, cb) {
-        const command = new DescribeDeviceFleetCommand(args);
+    };
+    SageMaker.prototype.describeDeviceFleet = function (args, optionsOrCb, cb) {
+        var command = new DescribeDeviceFleetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeDomain(args, optionsOrCb, cb) {
-        const command = new DescribeDomainCommand(args);
+    };
+    SageMaker.prototype.describeDomain = function (args, optionsOrCb, cb) {
+        var command = new DescribeDomainCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeEdgeDeploymentPlan(args, optionsOrCb, cb) {
-        const command = new DescribeEdgeDeploymentPlanCommand(args);
+    };
+    SageMaker.prototype.describeEdgeDeploymentPlan = function (args, optionsOrCb, cb) {
+        var command = new DescribeEdgeDeploymentPlanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeEdgePackagingJob(args, optionsOrCb, cb) {
-        const command = new DescribeEdgePackagingJobCommand(args);
+    };
+    SageMaker.prototype.describeEdgePackagingJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeEdgePackagingJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeEndpoint(args, optionsOrCb, cb) {
-        const command = new DescribeEndpointCommand(args);
+    };
+    SageMaker.prototype.describeEndpoint = function (args, optionsOrCb, cb) {
+        var command = new DescribeEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeEndpointConfig(args, optionsOrCb, cb) {
-        const command = new DescribeEndpointConfigCommand(args);
+    };
+    SageMaker.prototype.describeEndpointConfig = function (args, optionsOrCb, cb) {
+        var command = new DescribeEndpointConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeExperiment(args, optionsOrCb, cb) {
-        const command = new DescribeExperimentCommand(args);
+    };
+    SageMaker.prototype.describeExperiment = function (args, optionsOrCb, cb) {
+        var command = new DescribeExperimentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeFeatureGroup(args, optionsOrCb, cb) {
-        const command = new DescribeFeatureGroupCommand(args);
+    };
+    SageMaker.prototype.describeFeatureGroup = function (args, optionsOrCb, cb) {
+        var command = new DescribeFeatureGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeFeatureMetadata(args, optionsOrCb, cb) {
-        const command = new DescribeFeatureMetadataCommand(args);
+    };
+    SageMaker.prototype.describeFeatureMetadata = function (args, optionsOrCb, cb) {
+        var command = new DescribeFeatureMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeFlowDefinition(args, optionsOrCb, cb) {
-        const command = new DescribeFlowDefinitionCommand(args);
+    };
+    SageMaker.prototype.describeFlowDefinition = function (args, optionsOrCb, cb) {
+        var command = new DescribeFlowDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeHumanTaskUi(args, optionsOrCb, cb) {
-        const command = new DescribeHumanTaskUiCommand(args);
+    };
+    SageMaker.prototype.describeHumanTaskUi = function (args, optionsOrCb, cb) {
+        var command = new DescribeHumanTaskUiCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeHyperParameterTuningJob(args, optionsOrCb, cb) {
-        const command = new DescribeHyperParameterTuningJobCommand(args);
+    };
+    SageMaker.prototype.describeHyperParameterTuningJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeHyperParameterTuningJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeImage(args, optionsOrCb, cb) {
-        const command = new DescribeImageCommand(args);
+    };
+    SageMaker.prototype.describeImage = function (args, optionsOrCb, cb) {
+        var command = new DescribeImageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeImageVersion(args, optionsOrCb, cb) {
-        const command = new DescribeImageVersionCommand(args);
+    };
+    SageMaker.prototype.describeImageVersion = function (args, optionsOrCb, cb) {
+        var command = new DescribeImageVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeInferenceRecommendationsJob(args, optionsOrCb, cb) {
-        const command = new DescribeInferenceRecommendationsJobCommand(args);
+    };
+    SageMaker.prototype.describeInferenceRecommendationsJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeInferenceRecommendationsJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeLabelingJob(args, optionsOrCb, cb) {
-        const command = new DescribeLabelingJobCommand(args);
+    };
+    SageMaker.prototype.describeLabelingJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeLabelingJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeLineageGroup(args, optionsOrCb, cb) {
-        const command = new DescribeLineageGroupCommand(args);
+    };
+    SageMaker.prototype.describeLineageGroup = function (args, optionsOrCb, cb) {
+        var command = new DescribeLineageGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeModel(args, optionsOrCb, cb) {
-        const command = new DescribeModelCommand(args);
+    };
+    SageMaker.prototype.describeModel = function (args, optionsOrCb, cb) {
+        var command = new DescribeModelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeModelBiasJobDefinition(args, optionsOrCb, cb) {
-        const command = new DescribeModelBiasJobDefinitionCommand(args);
+    };
+    SageMaker.prototype.describeModelBiasJobDefinition = function (args, optionsOrCb, cb) {
+        var command = new DescribeModelBiasJobDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeModelExplainabilityJobDefinition(args, optionsOrCb, cb) {
-        const command = new DescribeModelExplainabilityJobDefinitionCommand(args);
+    };
+    SageMaker.prototype.describeModelExplainabilityJobDefinition = function (args, optionsOrCb, cb) {
+        var command = new DescribeModelExplainabilityJobDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeModelPackage(args, optionsOrCb, cb) {
-        const command = new DescribeModelPackageCommand(args);
+    };
+    SageMaker.prototype.describeModelPackage = function (args, optionsOrCb, cb) {
+        var command = new DescribeModelPackageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeModelPackageGroup(args, optionsOrCb, cb) {
-        const command = new DescribeModelPackageGroupCommand(args);
+    };
+    SageMaker.prototype.describeModelPackageGroup = function (args, optionsOrCb, cb) {
+        var command = new DescribeModelPackageGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeModelQualityJobDefinition(args, optionsOrCb, cb) {
-        const command = new DescribeModelQualityJobDefinitionCommand(args);
+    };
+    SageMaker.prototype.describeModelQualityJobDefinition = function (args, optionsOrCb, cb) {
+        var command = new DescribeModelQualityJobDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeMonitoringSchedule(args, optionsOrCb, cb) {
-        const command = new DescribeMonitoringScheduleCommand(args);
+    };
+    SageMaker.prototype.describeMonitoringSchedule = function (args, optionsOrCb, cb) {
+        var command = new DescribeMonitoringScheduleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeNotebookInstance(args, optionsOrCb, cb) {
-        const command = new DescribeNotebookInstanceCommand(args);
+    };
+    SageMaker.prototype.describeNotebookInstance = function (args, optionsOrCb, cb) {
+        var command = new DescribeNotebookInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeNotebookInstanceLifecycleConfig(args, optionsOrCb, cb) {
-        const command = new DescribeNotebookInstanceLifecycleConfigCommand(args);
+    };
+    SageMaker.prototype.describeNotebookInstanceLifecycleConfig = function (args, optionsOrCb, cb) {
+        var command = new DescribeNotebookInstanceLifecycleConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describePipeline(args, optionsOrCb, cb) {
-        const command = new DescribePipelineCommand(args);
+    };
+    SageMaker.prototype.describePipeline = function (args, optionsOrCb, cb) {
+        var command = new DescribePipelineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describePipelineDefinitionForExecution(args, optionsOrCb, cb) {
-        const command = new DescribePipelineDefinitionForExecutionCommand(args);
+    };
+    SageMaker.prototype.describePipelineDefinitionForExecution = function (args, optionsOrCb, cb) {
+        var command = new DescribePipelineDefinitionForExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describePipelineExecution(args, optionsOrCb, cb) {
-        const command = new DescribePipelineExecutionCommand(args);
+    };
+    SageMaker.prototype.describePipelineExecution = function (args, optionsOrCb, cb) {
+        var command = new DescribePipelineExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeProcessingJob(args, optionsOrCb, cb) {
-        const command = new DescribeProcessingJobCommand(args);
+    };
+    SageMaker.prototype.describeProcessingJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeProcessingJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeProject(args, optionsOrCb, cb) {
-        const command = new DescribeProjectCommand(args);
+    };
+    SageMaker.prototype.describeProject = function (args, optionsOrCb, cb) {
+        var command = new DescribeProjectCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeStudioLifecycleConfig(args, optionsOrCb, cb) {
-        const command = new DescribeStudioLifecycleConfigCommand(args);
+    };
+    SageMaker.prototype.describeStudioLifecycleConfig = function (args, optionsOrCb, cb) {
+        var command = new DescribeStudioLifecycleConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeSubscribedWorkteam(args, optionsOrCb, cb) {
-        const command = new DescribeSubscribedWorkteamCommand(args);
+    };
+    SageMaker.prototype.describeSubscribedWorkteam = function (args, optionsOrCb, cb) {
+        var command = new DescribeSubscribedWorkteamCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeTrainingJob(args, optionsOrCb, cb) {
-        const command = new DescribeTrainingJobCommand(args);
+    };
+    SageMaker.prototype.describeTrainingJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeTrainingJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeTransformJob(args, optionsOrCb, cb) {
-        const command = new DescribeTransformJobCommand(args);
+    };
+    SageMaker.prototype.describeTransformJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeTransformJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeTrial(args, optionsOrCb, cb) {
-        const command = new DescribeTrialCommand(args);
+    };
+    SageMaker.prototype.describeTrial = function (args, optionsOrCb, cb) {
+        var command = new DescribeTrialCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeTrialComponent(args, optionsOrCb, cb) {
-        const command = new DescribeTrialComponentCommand(args);
+    };
+    SageMaker.prototype.describeTrialComponent = function (args, optionsOrCb, cb) {
+        var command = new DescribeTrialComponentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeUserProfile(args, optionsOrCb, cb) {
-        const command = new DescribeUserProfileCommand(args);
+    };
+    SageMaker.prototype.describeUserProfile = function (args, optionsOrCb, cb) {
+        var command = new DescribeUserProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeWorkforce(args, optionsOrCb, cb) {
-        const command = new DescribeWorkforceCommand(args);
+    };
+    SageMaker.prototype.describeWorkforce = function (args, optionsOrCb, cb) {
+        var command = new DescribeWorkforceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeWorkteam(args, optionsOrCb, cb) {
-        const command = new DescribeWorkteamCommand(args);
+    };
+    SageMaker.prototype.describeWorkteam = function (args, optionsOrCb, cb) {
+        var command = new DescribeWorkteamCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    disableSagemakerServicecatalogPortfolio(args, optionsOrCb, cb) {
-        const command = new DisableSagemakerServicecatalogPortfolioCommand(args);
+    };
+    SageMaker.prototype.disableSagemakerServicecatalogPortfolio = function (args, optionsOrCb, cb) {
+        var command = new DisableSagemakerServicecatalogPortfolioCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    disassociateTrialComponent(args, optionsOrCb, cb) {
-        const command = new DisassociateTrialComponentCommand(args);
+    };
+    SageMaker.prototype.disassociateTrialComponent = function (args, optionsOrCb, cb) {
+        var command = new DisassociateTrialComponentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    enableSagemakerServicecatalogPortfolio(args, optionsOrCb, cb) {
-        const command = new EnableSagemakerServicecatalogPortfolioCommand(args);
+    };
+    SageMaker.prototype.enableSagemakerServicecatalogPortfolio = function (args, optionsOrCb, cb) {
+        var command = new EnableSagemakerServicecatalogPortfolioCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDeviceFleetReport(args, optionsOrCb, cb) {
-        const command = new GetDeviceFleetReportCommand(args);
+    };
+    SageMaker.prototype.getDeviceFleetReport = function (args, optionsOrCb, cb) {
+        var command = new GetDeviceFleetReportCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getLineageGroupPolicy(args, optionsOrCb, cb) {
-        const command = new GetLineageGroupPolicyCommand(args);
+    };
+    SageMaker.prototype.getLineageGroupPolicy = function (args, optionsOrCb, cb) {
+        var command = new GetLineageGroupPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getModelPackageGroupPolicy(args, optionsOrCb, cb) {
-        const command = new GetModelPackageGroupPolicyCommand(args);
+    };
+    SageMaker.prototype.getModelPackageGroupPolicy = function (args, optionsOrCb, cb) {
+        var command = new GetModelPackageGroupPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSagemakerServicecatalogPortfolioStatus(args, optionsOrCb, cb) {
-        const command = new GetSagemakerServicecatalogPortfolioStatusCommand(args);
+    };
+    SageMaker.prototype.getSagemakerServicecatalogPortfolioStatus = function (args, optionsOrCb, cb) {
+        var command = new GetSagemakerServicecatalogPortfolioStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSearchSuggestions(args, optionsOrCb, cb) {
-        const command = new GetSearchSuggestionsCommand(args);
+    };
+    SageMaker.prototype.getSearchSuggestions = function (args, optionsOrCb, cb) {
+        var command = new GetSearchSuggestionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listActions(args, optionsOrCb, cb) {
-        const command = new ListActionsCommand(args);
+    };
+    SageMaker.prototype.listActions = function (args, optionsOrCb, cb) {
+        var command = new ListActionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listAlgorithms(args, optionsOrCb, cb) {
-        const command = new ListAlgorithmsCommand(args);
+    };
+    SageMaker.prototype.listAlgorithms = function (args, optionsOrCb, cb) {
+        var command = new ListAlgorithmsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listAppImageConfigs(args, optionsOrCb, cb) {
-        const command = new ListAppImageConfigsCommand(args);
+    };
+    SageMaker.prototype.listAppImageConfigs = function (args, optionsOrCb, cb) {
+        var command = new ListAppImageConfigsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listApps(args, optionsOrCb, cb) {
-        const command = new ListAppsCommand(args);
+    };
+    SageMaker.prototype.listApps = function (args, optionsOrCb, cb) {
+        var command = new ListAppsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listArtifacts(args, optionsOrCb, cb) {
-        const command = new ListArtifactsCommand(args);
+    };
+    SageMaker.prototype.listArtifacts = function (args, optionsOrCb, cb) {
+        var command = new ListArtifactsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listAssociations(args, optionsOrCb, cb) {
-        const command = new ListAssociationsCommand(args);
+    };
+    SageMaker.prototype.listAssociations = function (args, optionsOrCb, cb) {
+        var command = new ListAssociationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listAutoMLJobs(args, optionsOrCb, cb) {
-        const command = new ListAutoMLJobsCommand(args);
+    };
+    SageMaker.prototype.listAutoMLJobs = function (args, optionsOrCb, cb) {
+        var command = new ListAutoMLJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listCandidatesForAutoMLJob(args, optionsOrCb, cb) {
-        const command = new ListCandidatesForAutoMLJobCommand(args);
+    };
+    SageMaker.prototype.listCandidatesForAutoMLJob = function (args, optionsOrCb, cb) {
+        var command = new ListCandidatesForAutoMLJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listCodeRepositories(args, optionsOrCb, cb) {
-        const command = new ListCodeRepositoriesCommand(args);
+    };
+    SageMaker.prototype.listCodeRepositories = function (args, optionsOrCb, cb) {
+        var command = new ListCodeRepositoriesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listCompilationJobs(args, optionsOrCb, cb) {
-        const command = new ListCompilationJobsCommand(args);
+    };
+    SageMaker.prototype.listCompilationJobs = function (args, optionsOrCb, cb) {
+        var command = new ListCompilationJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listContexts(args, optionsOrCb, cb) {
-        const command = new ListContextsCommand(args);
+    };
+    SageMaker.prototype.listContexts = function (args, optionsOrCb, cb) {
+        var command = new ListContextsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDataQualityJobDefinitions(args, optionsOrCb, cb) {
-        const command = new ListDataQualityJobDefinitionsCommand(args);
+    };
+    SageMaker.prototype.listDataQualityJobDefinitions = function (args, optionsOrCb, cb) {
+        var command = new ListDataQualityJobDefinitionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDeviceFleets(args, optionsOrCb, cb) {
-        const command = new ListDeviceFleetsCommand(args);
+    };
+    SageMaker.prototype.listDeviceFleets = function (args, optionsOrCb, cb) {
+        var command = new ListDeviceFleetsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDevices(args, optionsOrCb, cb) {
-        const command = new ListDevicesCommand(args);
+    };
+    SageMaker.prototype.listDevices = function (args, optionsOrCb, cb) {
+        var command = new ListDevicesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDomains(args, optionsOrCb, cb) {
-        const command = new ListDomainsCommand(args);
+    };
+    SageMaker.prototype.listDomains = function (args, optionsOrCb, cb) {
+        var command = new ListDomainsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listEdgeDeploymentPlans(args, optionsOrCb, cb) {
-        const command = new ListEdgeDeploymentPlansCommand(args);
+    };
+    SageMaker.prototype.listEdgeDeploymentPlans = function (args, optionsOrCb, cb) {
+        var command = new ListEdgeDeploymentPlansCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listEdgePackagingJobs(args, optionsOrCb, cb) {
-        const command = new ListEdgePackagingJobsCommand(args);
+    };
+    SageMaker.prototype.listEdgePackagingJobs = function (args, optionsOrCb, cb) {
+        var command = new ListEdgePackagingJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listEndpointConfigs(args, optionsOrCb, cb) {
-        const command = new ListEndpointConfigsCommand(args);
+    };
+    SageMaker.prototype.listEndpointConfigs = function (args, optionsOrCb, cb) {
+        var command = new ListEndpointConfigsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listEndpoints(args, optionsOrCb, cb) {
-        const command = new ListEndpointsCommand(args);
+    };
+    SageMaker.prototype.listEndpoints = function (args, optionsOrCb, cb) {
+        var command = new ListEndpointsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listExperiments(args, optionsOrCb, cb) {
-        const command = new ListExperimentsCommand(args);
+    };
+    SageMaker.prototype.listExperiments = function (args, optionsOrCb, cb) {
+        var command = new ListExperimentsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listFeatureGroups(args, optionsOrCb, cb) {
-        const command = new ListFeatureGroupsCommand(args);
+    };
+    SageMaker.prototype.listFeatureGroups = function (args, optionsOrCb, cb) {
+        var command = new ListFeatureGroupsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listFlowDefinitions(args, optionsOrCb, cb) {
-        const command = new ListFlowDefinitionsCommand(args);
+    };
+    SageMaker.prototype.listFlowDefinitions = function (args, optionsOrCb, cb) {
+        var command = new ListFlowDefinitionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listHumanTaskUis(args, optionsOrCb, cb) {
-        const command = new ListHumanTaskUisCommand(args);
+    };
+    SageMaker.prototype.listHumanTaskUis = function (args, optionsOrCb, cb) {
+        var command = new ListHumanTaskUisCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listHyperParameterTuningJobs(args, optionsOrCb, cb) {
-        const command = new ListHyperParameterTuningJobsCommand(args);
+    };
+    SageMaker.prototype.listHyperParameterTuningJobs = function (args, optionsOrCb, cb) {
+        var command = new ListHyperParameterTuningJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listImages(args, optionsOrCb, cb) {
-        const command = new ListImagesCommand(args);
+    };
+    SageMaker.prototype.listImages = function (args, optionsOrCb, cb) {
+        var command = new ListImagesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listImageVersions(args, optionsOrCb, cb) {
-        const command = new ListImageVersionsCommand(args);
+    };
+    SageMaker.prototype.listImageVersions = function (args, optionsOrCb, cb) {
+        var command = new ListImageVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listInferenceRecommendationsJobs(args, optionsOrCb, cb) {
-        const command = new ListInferenceRecommendationsJobsCommand(args);
+    };
+    SageMaker.prototype.listInferenceRecommendationsJobs = function (args, optionsOrCb, cb) {
+        var command = new ListInferenceRecommendationsJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listLabelingJobs(args, optionsOrCb, cb) {
-        const command = new ListLabelingJobsCommand(args);
+    };
+    SageMaker.prototype.listLabelingJobs = function (args, optionsOrCb, cb) {
+        var command = new ListLabelingJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listLabelingJobsForWorkteam(args, optionsOrCb, cb) {
-        const command = new ListLabelingJobsForWorkteamCommand(args);
+    };
+    SageMaker.prototype.listLabelingJobsForWorkteam = function (args, optionsOrCb, cb) {
+        var command = new ListLabelingJobsForWorkteamCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listLineageGroups(args, optionsOrCb, cb) {
-        const command = new ListLineageGroupsCommand(args);
+    };
+    SageMaker.prototype.listLineageGroups = function (args, optionsOrCb, cb) {
+        var command = new ListLineageGroupsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listModelBiasJobDefinitions(args, optionsOrCb, cb) {
-        const command = new ListModelBiasJobDefinitionsCommand(args);
+    };
+    SageMaker.prototype.listModelBiasJobDefinitions = function (args, optionsOrCb, cb) {
+        var command = new ListModelBiasJobDefinitionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listModelExplainabilityJobDefinitions(args, optionsOrCb, cb) {
-        const command = new ListModelExplainabilityJobDefinitionsCommand(args);
+    };
+    SageMaker.prototype.listModelExplainabilityJobDefinitions = function (args, optionsOrCb, cb) {
+        var command = new ListModelExplainabilityJobDefinitionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listModelMetadata(args, optionsOrCb, cb) {
-        const command = new ListModelMetadataCommand(args);
+    };
+    SageMaker.prototype.listModelMetadata = function (args, optionsOrCb, cb) {
+        var command = new ListModelMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listModelPackageGroups(args, optionsOrCb, cb) {
-        const command = new ListModelPackageGroupsCommand(args);
+    };
+    SageMaker.prototype.listModelPackageGroups = function (args, optionsOrCb, cb) {
+        var command = new ListModelPackageGroupsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listModelPackages(args, optionsOrCb, cb) {
-        const command = new ListModelPackagesCommand(args);
+    };
+    SageMaker.prototype.listModelPackages = function (args, optionsOrCb, cb) {
+        var command = new ListModelPackagesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listModelQualityJobDefinitions(args, optionsOrCb, cb) {
-        const command = new ListModelQualityJobDefinitionsCommand(args);
+    };
+    SageMaker.prototype.listModelQualityJobDefinitions = function (args, optionsOrCb, cb) {
+        var command = new ListModelQualityJobDefinitionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listModels(args, optionsOrCb, cb) {
-        const command = new ListModelsCommand(args);
+    };
+    SageMaker.prototype.listModels = function (args, optionsOrCb, cb) {
+        var command = new ListModelsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listMonitoringExecutions(args, optionsOrCb, cb) {
-        const command = new ListMonitoringExecutionsCommand(args);
+    };
+    SageMaker.prototype.listMonitoringExecutions = function (args, optionsOrCb, cb) {
+        var command = new ListMonitoringExecutionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listMonitoringSchedules(args, optionsOrCb, cb) {
-        const command = new ListMonitoringSchedulesCommand(args);
+    };
+    SageMaker.prototype.listMonitoringSchedules = function (args, optionsOrCb, cb) {
+        var command = new ListMonitoringSchedulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listNotebookInstanceLifecycleConfigs(args, optionsOrCb, cb) {
-        const command = new ListNotebookInstanceLifecycleConfigsCommand(args);
+    };
+    SageMaker.prototype.listNotebookInstanceLifecycleConfigs = function (args, optionsOrCb, cb) {
+        var command = new ListNotebookInstanceLifecycleConfigsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listNotebookInstances(args, optionsOrCb, cb) {
-        const command = new ListNotebookInstancesCommand(args);
+    };
+    SageMaker.prototype.listNotebookInstances = function (args, optionsOrCb, cb) {
+        var command = new ListNotebookInstancesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listPipelineExecutions(args, optionsOrCb, cb) {
-        const command = new ListPipelineExecutionsCommand(args);
+    };
+    SageMaker.prototype.listPipelineExecutions = function (args, optionsOrCb, cb) {
+        var command = new ListPipelineExecutionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listPipelineExecutionSteps(args, optionsOrCb, cb) {
-        const command = new ListPipelineExecutionStepsCommand(args);
+    };
+    SageMaker.prototype.listPipelineExecutionSteps = function (args, optionsOrCb, cb) {
+        var command = new ListPipelineExecutionStepsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listPipelineParametersForExecution(args, optionsOrCb, cb) {
-        const command = new ListPipelineParametersForExecutionCommand(args);
+    };
+    SageMaker.prototype.listPipelineParametersForExecution = function (args, optionsOrCb, cb) {
+        var command = new ListPipelineParametersForExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listPipelines(args, optionsOrCb, cb) {
-        const command = new ListPipelinesCommand(args);
+    };
+    SageMaker.prototype.listPipelines = function (args, optionsOrCb, cb) {
+        var command = new ListPipelinesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listProcessingJobs(args, optionsOrCb, cb) {
-        const command = new ListProcessingJobsCommand(args);
+    };
+    SageMaker.prototype.listProcessingJobs = function (args, optionsOrCb, cb) {
+        var command = new ListProcessingJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listProjects(args, optionsOrCb, cb) {
-        const command = new ListProjectsCommand(args);
+    };
+    SageMaker.prototype.listProjects = function (args, optionsOrCb, cb) {
+        var command = new ListProjectsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listStageDevices(args, optionsOrCb, cb) {
-        const command = new ListStageDevicesCommand(args);
+    };
+    SageMaker.prototype.listStageDevices = function (args, optionsOrCb, cb) {
+        var command = new ListStageDevicesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listStudioLifecycleConfigs(args, optionsOrCb, cb) {
-        const command = new ListStudioLifecycleConfigsCommand(args);
+    };
+    SageMaker.prototype.listStudioLifecycleConfigs = function (args, optionsOrCb, cb) {
+        var command = new ListStudioLifecycleConfigsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listSubscribedWorkteams(args, optionsOrCb, cb) {
-        const command = new ListSubscribedWorkteamsCommand(args);
+    };
+    SageMaker.prototype.listSubscribedWorkteams = function (args, optionsOrCb, cb) {
+        var command = new ListSubscribedWorkteamsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTags(args, optionsOrCb, cb) {
-        const command = new ListTagsCommand(args);
+    };
+    SageMaker.prototype.listTags = function (args, optionsOrCb, cb) {
+        var command = new ListTagsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTrainingJobs(args, optionsOrCb, cb) {
-        const command = new ListTrainingJobsCommand(args);
+    };
+    SageMaker.prototype.listTrainingJobs = function (args, optionsOrCb, cb) {
+        var command = new ListTrainingJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTrainingJobsForHyperParameterTuningJob(args, optionsOrCb, cb) {
-        const command = new ListTrainingJobsForHyperParameterTuningJobCommand(args);
+    };
+    SageMaker.prototype.listTrainingJobsForHyperParameterTuningJob = function (args, optionsOrCb, cb) {
+        var command = new ListTrainingJobsForHyperParameterTuningJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTransformJobs(args, optionsOrCb, cb) {
-        const command = new ListTransformJobsCommand(args);
+    };
+    SageMaker.prototype.listTransformJobs = function (args, optionsOrCb, cb) {
+        var command = new ListTransformJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTrialComponents(args, optionsOrCb, cb) {
-        const command = new ListTrialComponentsCommand(args);
+    };
+    SageMaker.prototype.listTrialComponents = function (args, optionsOrCb, cb) {
+        var command = new ListTrialComponentsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTrials(args, optionsOrCb, cb) {
-        const command = new ListTrialsCommand(args);
+    };
+    SageMaker.prototype.listTrials = function (args, optionsOrCb, cb) {
+        var command = new ListTrialsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listUserProfiles(args, optionsOrCb, cb) {
-        const command = new ListUserProfilesCommand(args);
+    };
+    SageMaker.prototype.listUserProfiles = function (args, optionsOrCb, cb) {
+        var command = new ListUserProfilesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listWorkforces(args, optionsOrCb, cb) {
-        const command = new ListWorkforcesCommand(args);
+    };
+    SageMaker.prototype.listWorkforces = function (args, optionsOrCb, cb) {
+        var command = new ListWorkforcesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listWorkteams(args, optionsOrCb, cb) {
-        const command = new ListWorkteamsCommand(args);
+    };
+    SageMaker.prototype.listWorkteams = function (args, optionsOrCb, cb) {
+        var command = new ListWorkteamsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putModelPackageGroupPolicy(args, optionsOrCb, cb) {
-        const command = new PutModelPackageGroupPolicyCommand(args);
+    };
+    SageMaker.prototype.putModelPackageGroupPolicy = function (args, optionsOrCb, cb) {
+        var command = new PutModelPackageGroupPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    queryLineage(args, optionsOrCb, cb) {
-        const command = new QueryLineageCommand(args);
+    };
+    SageMaker.prototype.queryLineage = function (args, optionsOrCb, cb) {
+        var command = new QueryLineageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    registerDevices(args, optionsOrCb, cb) {
-        const command = new RegisterDevicesCommand(args);
+    };
+    SageMaker.prototype.registerDevices = function (args, optionsOrCb, cb) {
+        var command = new RegisterDevicesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    renderUiTemplate(args, optionsOrCb, cb) {
-        const command = new RenderUiTemplateCommand(args);
+    };
+    SageMaker.prototype.renderUiTemplate = function (args, optionsOrCb, cb) {
+        var command = new RenderUiTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    retryPipelineExecution(args, optionsOrCb, cb) {
-        const command = new RetryPipelineExecutionCommand(args);
+    };
+    SageMaker.prototype.retryPipelineExecution = function (args, optionsOrCb, cb) {
+        var command = new RetryPipelineExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    search(args, optionsOrCb, cb) {
-        const command = new SearchCommand(args);
+    };
+    SageMaker.prototype.search = function (args, optionsOrCb, cb) {
+        var command = new SearchCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    sendPipelineExecutionStepFailure(args, optionsOrCb, cb) {
-        const command = new SendPipelineExecutionStepFailureCommand(args);
+    };
+    SageMaker.prototype.sendPipelineExecutionStepFailure = function (args, optionsOrCb, cb) {
+        var command = new SendPipelineExecutionStepFailureCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    sendPipelineExecutionStepSuccess(args, optionsOrCb, cb) {
-        const command = new SendPipelineExecutionStepSuccessCommand(args);
+    };
+    SageMaker.prototype.sendPipelineExecutionStepSuccess = function (args, optionsOrCb, cb) {
+        var command = new SendPipelineExecutionStepSuccessCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startEdgeDeploymentStage(args, optionsOrCb, cb) {
-        const command = new StartEdgeDeploymentStageCommand(args);
+    };
+    SageMaker.prototype.startEdgeDeploymentStage = function (args, optionsOrCb, cb) {
+        var command = new StartEdgeDeploymentStageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startMonitoringSchedule(args, optionsOrCb, cb) {
-        const command = new StartMonitoringScheduleCommand(args);
+    };
+    SageMaker.prototype.startMonitoringSchedule = function (args, optionsOrCb, cb) {
+        var command = new StartMonitoringScheduleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startNotebookInstance(args, optionsOrCb, cb) {
-        const command = new StartNotebookInstanceCommand(args);
+    };
+    SageMaker.prototype.startNotebookInstance = function (args, optionsOrCb, cb) {
+        var command = new StartNotebookInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startPipelineExecution(args, optionsOrCb, cb) {
-        const command = new StartPipelineExecutionCommand(args);
+    };
+    SageMaker.prototype.startPipelineExecution = function (args, optionsOrCb, cb) {
+        var command = new StartPipelineExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopAutoMLJob(args, optionsOrCb, cb) {
-        const command = new StopAutoMLJobCommand(args);
+    };
+    SageMaker.prototype.stopAutoMLJob = function (args, optionsOrCb, cb) {
+        var command = new StopAutoMLJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopCompilationJob(args, optionsOrCb, cb) {
-        const command = new StopCompilationJobCommand(args);
+    };
+    SageMaker.prototype.stopCompilationJob = function (args, optionsOrCb, cb) {
+        var command = new StopCompilationJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopEdgeDeploymentStage(args, optionsOrCb, cb) {
-        const command = new StopEdgeDeploymentStageCommand(args);
+    };
+    SageMaker.prototype.stopEdgeDeploymentStage = function (args, optionsOrCb, cb) {
+        var command = new StopEdgeDeploymentStageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopEdgePackagingJob(args, optionsOrCb, cb) {
-        const command = new StopEdgePackagingJobCommand(args);
+    };
+    SageMaker.prototype.stopEdgePackagingJob = function (args, optionsOrCb, cb) {
+        var command = new StopEdgePackagingJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopHyperParameterTuningJob(args, optionsOrCb, cb) {
-        const command = new StopHyperParameterTuningJobCommand(args);
+    };
+    SageMaker.prototype.stopHyperParameterTuningJob = function (args, optionsOrCb, cb) {
+        var command = new StopHyperParameterTuningJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopInferenceRecommendationsJob(args, optionsOrCb, cb) {
-        const command = new StopInferenceRecommendationsJobCommand(args);
+    };
+    SageMaker.prototype.stopInferenceRecommendationsJob = function (args, optionsOrCb, cb) {
+        var command = new StopInferenceRecommendationsJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopLabelingJob(args, optionsOrCb, cb) {
-        const command = new StopLabelingJobCommand(args);
+    };
+    SageMaker.prototype.stopLabelingJob = function (args, optionsOrCb, cb) {
+        var command = new StopLabelingJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopMonitoringSchedule(args, optionsOrCb, cb) {
-        const command = new StopMonitoringScheduleCommand(args);
+    };
+    SageMaker.prototype.stopMonitoringSchedule = function (args, optionsOrCb, cb) {
+        var command = new StopMonitoringScheduleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopNotebookInstance(args, optionsOrCb, cb) {
-        const command = new StopNotebookInstanceCommand(args);
+    };
+    SageMaker.prototype.stopNotebookInstance = function (args, optionsOrCb, cb) {
+        var command = new StopNotebookInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopPipelineExecution(args, optionsOrCb, cb) {
-        const command = new StopPipelineExecutionCommand(args);
+    };
+    SageMaker.prototype.stopPipelineExecution = function (args, optionsOrCb, cb) {
+        var command = new StopPipelineExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopProcessingJob(args, optionsOrCb, cb) {
-        const command = new StopProcessingJobCommand(args);
+    };
+    SageMaker.prototype.stopProcessingJob = function (args, optionsOrCb, cb) {
+        var command = new StopProcessingJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopTrainingJob(args, optionsOrCb, cb) {
-        const command = new StopTrainingJobCommand(args);
+    };
+    SageMaker.prototype.stopTrainingJob = function (args, optionsOrCb, cb) {
+        var command = new StopTrainingJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopTransformJob(args, optionsOrCb, cb) {
-        const command = new StopTransformJobCommand(args);
+    };
+    SageMaker.prototype.stopTransformJob = function (args, optionsOrCb, cb) {
+        var command = new StopTransformJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateAction(args, optionsOrCb, cb) {
-        const command = new UpdateActionCommand(args);
+    };
+    SageMaker.prototype.updateAction = function (args, optionsOrCb, cb) {
+        var command = new UpdateActionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateAppImageConfig(args, optionsOrCb, cb) {
-        const command = new UpdateAppImageConfigCommand(args);
+    };
+    SageMaker.prototype.updateAppImageConfig = function (args, optionsOrCb, cb) {
+        var command = new UpdateAppImageConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateArtifact(args, optionsOrCb, cb) {
-        const command = new UpdateArtifactCommand(args);
+    };
+    SageMaker.prototype.updateArtifact = function (args, optionsOrCb, cb) {
+        var command = new UpdateArtifactCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateCodeRepository(args, optionsOrCb, cb) {
-        const command = new UpdateCodeRepositoryCommand(args);
+    };
+    SageMaker.prototype.updateCodeRepository = function (args, optionsOrCb, cb) {
+        var command = new UpdateCodeRepositoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateContext(args, optionsOrCb, cb) {
-        const command = new UpdateContextCommand(args);
+    };
+    SageMaker.prototype.updateContext = function (args, optionsOrCb, cb) {
+        var command = new UpdateContextCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDeviceFleet(args, optionsOrCb, cb) {
-        const command = new UpdateDeviceFleetCommand(args);
+    };
+    SageMaker.prototype.updateDeviceFleet = function (args, optionsOrCb, cb) {
+        var command = new UpdateDeviceFleetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDevices(args, optionsOrCb, cb) {
-        const command = new UpdateDevicesCommand(args);
+    };
+    SageMaker.prototype.updateDevices = function (args, optionsOrCb, cb) {
+        var command = new UpdateDevicesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDomain(args, optionsOrCb, cb) {
-        const command = new UpdateDomainCommand(args);
+    };
+    SageMaker.prototype.updateDomain = function (args, optionsOrCb, cb) {
+        var command = new UpdateDomainCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateEndpoint(args, optionsOrCb, cb) {
-        const command = new UpdateEndpointCommand(args);
+    };
+    SageMaker.prototype.updateEndpoint = function (args, optionsOrCb, cb) {
+        var command = new UpdateEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateEndpointWeightsAndCapacities(args, optionsOrCb, cb) {
-        const command = new UpdateEndpointWeightsAndCapacitiesCommand(args);
+    };
+    SageMaker.prototype.updateEndpointWeightsAndCapacities = function (args, optionsOrCb, cb) {
+        var command = new UpdateEndpointWeightsAndCapacitiesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateExperiment(args, optionsOrCb, cb) {
-        const command = new UpdateExperimentCommand(args);
+    };
+    SageMaker.prototype.updateExperiment = function (args, optionsOrCb, cb) {
+        var command = new UpdateExperimentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateFeatureGroup(args, optionsOrCb, cb) {
-        const command = new UpdateFeatureGroupCommand(args);
+    };
+    SageMaker.prototype.updateFeatureGroup = function (args, optionsOrCb, cb) {
+        var command = new UpdateFeatureGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateFeatureMetadata(args, optionsOrCb, cb) {
-        const command = new UpdateFeatureMetadataCommand(args);
+    };
+    SageMaker.prototype.updateFeatureMetadata = function (args, optionsOrCb, cb) {
+        var command = new UpdateFeatureMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateImage(args, optionsOrCb, cb) {
-        const command = new UpdateImageCommand(args);
+    };
+    SageMaker.prototype.updateImage = function (args, optionsOrCb, cb) {
+        var command = new UpdateImageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateModelPackage(args, optionsOrCb, cb) {
-        const command = new UpdateModelPackageCommand(args);
+    };
+    SageMaker.prototype.updateModelPackage = function (args, optionsOrCb, cb) {
+        var command = new UpdateModelPackageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateMonitoringSchedule(args, optionsOrCb, cb) {
-        const command = new UpdateMonitoringScheduleCommand(args);
+    };
+    SageMaker.prototype.updateMonitoringSchedule = function (args, optionsOrCb, cb) {
+        var command = new UpdateMonitoringScheduleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateNotebookInstance(args, optionsOrCb, cb) {
-        const command = new UpdateNotebookInstanceCommand(args);
+    };
+    SageMaker.prototype.updateNotebookInstance = function (args, optionsOrCb, cb) {
+        var command = new UpdateNotebookInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateNotebookInstanceLifecycleConfig(args, optionsOrCb, cb) {
-        const command = new UpdateNotebookInstanceLifecycleConfigCommand(args);
+    };
+    SageMaker.prototype.updateNotebookInstanceLifecycleConfig = function (args, optionsOrCb, cb) {
+        var command = new UpdateNotebookInstanceLifecycleConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updatePipeline(args, optionsOrCb, cb) {
-        const command = new UpdatePipelineCommand(args);
+    };
+    SageMaker.prototype.updatePipeline = function (args, optionsOrCb, cb) {
+        var command = new UpdatePipelineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updatePipelineExecution(args, optionsOrCb, cb) {
-        const command = new UpdatePipelineExecutionCommand(args);
+    };
+    SageMaker.prototype.updatePipelineExecution = function (args, optionsOrCb, cb) {
+        var command = new UpdatePipelineExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateProject(args, optionsOrCb, cb) {
-        const command = new UpdateProjectCommand(args);
+    };
+    SageMaker.prototype.updateProject = function (args, optionsOrCb, cb) {
+        var command = new UpdateProjectCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateTrainingJob(args, optionsOrCb, cb) {
-        const command = new UpdateTrainingJobCommand(args);
+    };
+    SageMaker.prototype.updateTrainingJob = function (args, optionsOrCb, cb) {
+        var command = new UpdateTrainingJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateTrial(args, optionsOrCb, cb) {
-        const command = new UpdateTrialCommand(args);
+    };
+    SageMaker.prototype.updateTrial = function (args, optionsOrCb, cb) {
+        var command = new UpdateTrialCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateTrialComponent(args, optionsOrCb, cb) {
-        const command = new UpdateTrialComponentCommand(args);
+    };
+    SageMaker.prototype.updateTrialComponent = function (args, optionsOrCb, cb) {
+        var command = new UpdateTrialComponentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateUserProfile(args, optionsOrCb, cb) {
-        const command = new UpdateUserProfileCommand(args);
+    };
+    SageMaker.prototype.updateUserProfile = function (args, optionsOrCb, cb) {
+        var command = new UpdateUserProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateWorkforce(args, optionsOrCb, cb) {
-        const command = new UpdateWorkforceCommand(args);
+    };
+    SageMaker.prototype.updateWorkforce = function (args, optionsOrCb, cb) {
+        var command = new UpdateWorkforceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateWorkteam(args, optionsOrCb, cb) {
-        const command = new UpdateWorkteamCommand(args);
+    };
+    SageMaker.prototype.updateWorkteam = function (args, optionsOrCb, cb) {
+        var command = new UpdateWorkteamCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-}
+    };
+    return SageMaker;
+}(SageMakerClient));
+export { SageMaker };