@aws-sdk/client-ssm 3.183.0 → 3.185.0

package/dist-es/SSM.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { AddTagsToResourceCommand, } from "./commands/AddTagsToResourceCommand";
 import { AssociateOpsItemRelatedItemCommand, } from "./commands/AssociateOpsItemRelatedItemCommand";
 import { CancelCommandCommand, } from "./commands/CancelCommandCommand";
@@ -134,1895 +135,1901 @@ import { UpdatePatchBaselineCommand, } from "./commands/UpdatePatchBaselineComma
 import { UpdateResourceDataSyncCommand, } from "./commands/UpdateResourceDataSyncCommand";
 import { UpdateServiceSettingCommand, } from "./commands/UpdateServiceSettingCommand";
 import { SSMClient } from "./SSMClient";
-export class SSM extends SSMClient {
-    addTagsToResource(args, optionsOrCb, cb) {
-        const command = new AddTagsToResourceCommand(args);
+var SSM = (function (_super) {
+    __extends(SSM, _super);
+    function SSM() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SSM.prototype.addTagsToResource = function (args, optionsOrCb, cb) {
+        var command = new AddTagsToResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    associateOpsItemRelatedItem(args, optionsOrCb, cb) {
-        const command = new AssociateOpsItemRelatedItemCommand(args);
+    };
+    SSM.prototype.associateOpsItemRelatedItem = function (args, optionsOrCb, cb) {
+        var command = new AssociateOpsItemRelatedItemCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    cancelCommand(args, optionsOrCb, cb) {
-        const command = new CancelCommandCommand(args);
+    };
+    SSM.prototype.cancelCommand = function (args, optionsOrCb, cb) {
+        var command = new CancelCommandCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    cancelMaintenanceWindowExecution(args, optionsOrCb, cb) {
-        const command = new CancelMaintenanceWindowExecutionCommand(args);
+    };
+    SSM.prototype.cancelMaintenanceWindowExecution = function (args, optionsOrCb, cb) {
+        var command = new CancelMaintenanceWindowExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createActivation(args, optionsOrCb, cb) {
-        const command = new CreateActivationCommand(args);
+    };
+    SSM.prototype.createActivation = function (args, optionsOrCb, cb) {
+        var command = new CreateActivationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createAssociation(args, optionsOrCb, cb) {
-        const command = new CreateAssociationCommand(args);
+    };
+    SSM.prototype.createAssociation = function (args, optionsOrCb, cb) {
+        var command = new CreateAssociationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createAssociationBatch(args, optionsOrCb, cb) {
-        const command = new CreateAssociationBatchCommand(args);
+    };
+    SSM.prototype.createAssociationBatch = function (args, optionsOrCb, cb) {
+        var command = new CreateAssociationBatchCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDocument(args, optionsOrCb, cb) {
-        const command = new CreateDocumentCommand(args);
+    };
+    SSM.prototype.createDocument = function (args, optionsOrCb, cb) {
+        var command = new CreateDocumentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createMaintenanceWindow(args, optionsOrCb, cb) {
-        const command = new CreateMaintenanceWindowCommand(args);
+    };
+    SSM.prototype.createMaintenanceWindow = function (args, optionsOrCb, cb) {
+        var command = new CreateMaintenanceWindowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createOpsItem(args, optionsOrCb, cb) {
-        const command = new CreateOpsItemCommand(args);
+    };
+    SSM.prototype.createOpsItem = function (args, optionsOrCb, cb) {
+        var command = new CreateOpsItemCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createOpsMetadata(args, optionsOrCb, cb) {
-        const command = new CreateOpsMetadataCommand(args);
+    };
+    SSM.prototype.createOpsMetadata = function (args, optionsOrCb, cb) {
+        var command = new CreateOpsMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createPatchBaseline(args, optionsOrCb, cb) {
-        const command = new CreatePatchBaselineCommand(args);
+    };
+    SSM.prototype.createPatchBaseline = function (args, optionsOrCb, cb) {
+        var command = new CreatePatchBaselineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createResourceDataSync(args, optionsOrCb, cb) {
-        const command = new CreateResourceDataSyncCommand(args);
+    };
+    SSM.prototype.createResourceDataSync = function (args, optionsOrCb, cb) {
+        var command = new CreateResourceDataSyncCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteActivation(args, optionsOrCb, cb) {
-        const command = new DeleteActivationCommand(args);
+    };
+    SSM.prototype.deleteActivation = function (args, optionsOrCb, cb) {
+        var command = new DeleteActivationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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);
+    };
+    SSM.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);
         }
-    }
-    deleteDocument(args, optionsOrCb, cb) {
-        const command = new DeleteDocumentCommand(args);
+    };
+    SSM.prototype.deleteDocument = function (args, optionsOrCb, cb) {
+        var command = new DeleteDocumentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteInventory(args, optionsOrCb, cb) {
-        const command = new DeleteInventoryCommand(args);
+    };
+    SSM.prototype.deleteInventory = function (args, optionsOrCb, cb) {
+        var command = new DeleteInventoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteMaintenanceWindow(args, optionsOrCb, cb) {
-        const command = new DeleteMaintenanceWindowCommand(args);
+    };
+    SSM.prototype.deleteMaintenanceWindow = function (args, optionsOrCb, cb) {
+        var command = new DeleteMaintenanceWindowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteOpsMetadata(args, optionsOrCb, cb) {
-        const command = new DeleteOpsMetadataCommand(args);
+    };
+    SSM.prototype.deleteOpsMetadata = function (args, optionsOrCb, cb) {
+        var command = new DeleteOpsMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteParameter(args, optionsOrCb, cb) {
-        const command = new DeleteParameterCommand(args);
+    };
+    SSM.prototype.deleteParameter = function (args, optionsOrCb, cb) {
+        var command = new DeleteParameterCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteParameters(args, optionsOrCb, cb) {
-        const command = new DeleteParametersCommand(args);
+    };
+    SSM.prototype.deleteParameters = function (args, optionsOrCb, cb) {
+        var command = new DeleteParametersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deletePatchBaseline(args, optionsOrCb, cb) {
-        const command = new DeletePatchBaselineCommand(args);
+    };
+    SSM.prototype.deletePatchBaseline = function (args, optionsOrCb, cb) {
+        var command = new DeletePatchBaselineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteResourceDataSync(args, optionsOrCb, cb) {
-        const command = new DeleteResourceDataSyncCommand(args);
+    };
+    SSM.prototype.deleteResourceDataSync = function (args, optionsOrCb, cb) {
+        var command = new DeleteResourceDataSyncCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deregisterManagedInstance(args, optionsOrCb, cb) {
-        const command = new DeregisterManagedInstanceCommand(args);
+    };
+    SSM.prototype.deregisterManagedInstance = function (args, optionsOrCb, cb) {
+        var command = new DeregisterManagedInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deregisterPatchBaselineForPatchGroup(args, optionsOrCb, cb) {
-        const command = new DeregisterPatchBaselineForPatchGroupCommand(args);
+    };
+    SSM.prototype.deregisterPatchBaselineForPatchGroup = function (args, optionsOrCb, cb) {
+        var command = new DeregisterPatchBaselineForPatchGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deregisterTargetFromMaintenanceWindow(args, optionsOrCb, cb) {
-        const command = new DeregisterTargetFromMaintenanceWindowCommand(args);
+    };
+    SSM.prototype.deregisterTargetFromMaintenanceWindow = function (args, optionsOrCb, cb) {
+        var command = new DeregisterTargetFromMaintenanceWindowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deregisterTaskFromMaintenanceWindow(args, optionsOrCb, cb) {
-        const command = new DeregisterTaskFromMaintenanceWindowCommand(args);
+    };
+    SSM.prototype.deregisterTaskFromMaintenanceWindow = function (args, optionsOrCb, cb) {
+        var command = new DeregisterTaskFromMaintenanceWindowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeActivations(args, optionsOrCb, cb) {
-        const command = new DescribeActivationsCommand(args);
+    };
+    SSM.prototype.describeActivations = function (args, optionsOrCb, cb) {
+        var command = new DescribeActivationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAssociation(args, optionsOrCb, cb) {
-        const command = new DescribeAssociationCommand(args);
+    };
+    SSM.prototype.describeAssociation = function (args, optionsOrCb, cb) {
+        var command = new DescribeAssociationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAssociationExecutions(args, optionsOrCb, cb) {
-        const command = new DescribeAssociationExecutionsCommand(args);
+    };
+    SSM.prototype.describeAssociationExecutions = function (args, optionsOrCb, cb) {
+        var command = new DescribeAssociationExecutionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAssociationExecutionTargets(args, optionsOrCb, cb) {
-        const command = new DescribeAssociationExecutionTargetsCommand(args);
+    };
+    SSM.prototype.describeAssociationExecutionTargets = function (args, optionsOrCb, cb) {
+        var command = new DescribeAssociationExecutionTargetsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAutomationExecutions(args, optionsOrCb, cb) {
-        const command = new DescribeAutomationExecutionsCommand(args);
+    };
+    SSM.prototype.describeAutomationExecutions = function (args, optionsOrCb, cb) {
+        var command = new DescribeAutomationExecutionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAutomationStepExecutions(args, optionsOrCb, cb) {
-        const command = new DescribeAutomationStepExecutionsCommand(args);
+    };
+    SSM.prototype.describeAutomationStepExecutions = function (args, optionsOrCb, cb) {
+        var command = new DescribeAutomationStepExecutionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAvailablePatches(args, optionsOrCb, cb) {
-        const command = new DescribeAvailablePatchesCommand(args);
+    };
+    SSM.prototype.describeAvailablePatches = function (args, optionsOrCb, cb) {
+        var command = new DescribeAvailablePatchesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeDocument(args, optionsOrCb, cb) {
-        const command = new DescribeDocumentCommand(args);
+    };
+    SSM.prototype.describeDocument = function (args, optionsOrCb, cb) {
+        var command = new DescribeDocumentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeDocumentPermission(args, optionsOrCb, cb) {
-        const command = new DescribeDocumentPermissionCommand(args);
+    };
+    SSM.prototype.describeDocumentPermission = function (args, optionsOrCb, cb) {
+        var command = new DescribeDocumentPermissionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeEffectiveInstanceAssociations(args, optionsOrCb, cb) {
-        const command = new DescribeEffectiveInstanceAssociationsCommand(args);
+    };
+    SSM.prototype.describeEffectiveInstanceAssociations = function (args, optionsOrCb, cb) {
+        var command = new DescribeEffectiveInstanceAssociationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeEffectivePatchesForPatchBaseline(args, optionsOrCb, cb) {
-        const command = new DescribeEffectivePatchesForPatchBaselineCommand(args);
+    };
+    SSM.prototype.describeEffectivePatchesForPatchBaseline = function (args, optionsOrCb, cb) {
+        var command = new DescribeEffectivePatchesForPatchBaselineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeInstanceAssociationsStatus(args, optionsOrCb, cb) {
-        const command = new DescribeInstanceAssociationsStatusCommand(args);
+    };
+    SSM.prototype.describeInstanceAssociationsStatus = function (args, optionsOrCb, cb) {
+        var command = new DescribeInstanceAssociationsStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeInstanceInformation(args, optionsOrCb, cb) {
-        const command = new DescribeInstanceInformationCommand(args);
+    };
+    SSM.prototype.describeInstanceInformation = function (args, optionsOrCb, cb) {
+        var command = new DescribeInstanceInformationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeInstancePatches(args, optionsOrCb, cb) {
-        const command = new DescribeInstancePatchesCommand(args);
+    };
+    SSM.prototype.describeInstancePatches = function (args, optionsOrCb, cb) {
+        var command = new DescribeInstancePatchesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeInstancePatchStates(args, optionsOrCb, cb) {
-        const command = new DescribeInstancePatchStatesCommand(args);
+    };
+    SSM.prototype.describeInstancePatchStates = function (args, optionsOrCb, cb) {
+        var command = new DescribeInstancePatchStatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeInstancePatchStatesForPatchGroup(args, optionsOrCb, cb) {
-        const command = new DescribeInstancePatchStatesForPatchGroupCommand(args);
+    };
+    SSM.prototype.describeInstancePatchStatesForPatchGroup = function (args, optionsOrCb, cb) {
+        var command = new DescribeInstancePatchStatesForPatchGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeInventoryDeletions(args, optionsOrCb, cb) {
-        const command = new DescribeInventoryDeletionsCommand(args);
+    };
+    SSM.prototype.describeInventoryDeletions = function (args, optionsOrCb, cb) {
+        var command = new DescribeInventoryDeletionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeMaintenanceWindowExecutions(args, optionsOrCb, cb) {
-        const command = new DescribeMaintenanceWindowExecutionsCommand(args);
+    };
+    SSM.prototype.describeMaintenanceWindowExecutions = function (args, optionsOrCb, cb) {
+        var command = new DescribeMaintenanceWindowExecutionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeMaintenanceWindowExecutionTaskInvocations(args, optionsOrCb, cb) {
-        const command = new DescribeMaintenanceWindowExecutionTaskInvocationsCommand(args);
+    };
+    SSM.prototype.describeMaintenanceWindowExecutionTaskInvocations = function (args, optionsOrCb, cb) {
+        var command = new DescribeMaintenanceWindowExecutionTaskInvocationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeMaintenanceWindowExecutionTasks(args, optionsOrCb, cb) {
-        const command = new DescribeMaintenanceWindowExecutionTasksCommand(args);
+    };
+    SSM.prototype.describeMaintenanceWindowExecutionTasks = function (args, optionsOrCb, cb) {
+        var command = new DescribeMaintenanceWindowExecutionTasksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeMaintenanceWindows(args, optionsOrCb, cb) {
-        const command = new DescribeMaintenanceWindowsCommand(args);
+    };
+    SSM.prototype.describeMaintenanceWindows = function (args, optionsOrCb, cb) {
+        var command = new DescribeMaintenanceWindowsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeMaintenanceWindowSchedule(args, optionsOrCb, cb) {
-        const command = new DescribeMaintenanceWindowScheduleCommand(args);
+    };
+    SSM.prototype.describeMaintenanceWindowSchedule = function (args, optionsOrCb, cb) {
+        var command = new DescribeMaintenanceWindowScheduleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeMaintenanceWindowsForTarget(args, optionsOrCb, cb) {
-        const command = new DescribeMaintenanceWindowsForTargetCommand(args);
+    };
+    SSM.prototype.describeMaintenanceWindowsForTarget = function (args, optionsOrCb, cb) {
+        var command = new DescribeMaintenanceWindowsForTargetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeMaintenanceWindowTargets(args, optionsOrCb, cb) {
-        const command = new DescribeMaintenanceWindowTargetsCommand(args);
+    };
+    SSM.prototype.describeMaintenanceWindowTargets = function (args, optionsOrCb, cb) {
+        var command = new DescribeMaintenanceWindowTargetsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeMaintenanceWindowTasks(args, optionsOrCb, cb) {
-        const command = new DescribeMaintenanceWindowTasksCommand(args);
+    };
+    SSM.prototype.describeMaintenanceWindowTasks = function (args, optionsOrCb, cb) {
+        var command = new DescribeMaintenanceWindowTasksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeOpsItems(args, optionsOrCb, cb) {
-        const command = new DescribeOpsItemsCommand(args);
+    };
+    SSM.prototype.describeOpsItems = function (args, optionsOrCb, cb) {
+        var command = new DescribeOpsItemsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeParameters(args, optionsOrCb, cb) {
-        const command = new DescribeParametersCommand(args);
+    };
+    SSM.prototype.describeParameters = function (args, optionsOrCb, cb) {
+        var command = new DescribeParametersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describePatchBaselines(args, optionsOrCb, cb) {
-        const command = new DescribePatchBaselinesCommand(args);
+    };
+    SSM.prototype.describePatchBaselines = function (args, optionsOrCb, cb) {
+        var command = new DescribePatchBaselinesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describePatchGroups(args, optionsOrCb, cb) {
-        const command = new DescribePatchGroupsCommand(args);
+    };
+    SSM.prototype.describePatchGroups = function (args, optionsOrCb, cb) {
+        var command = new DescribePatchGroupsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describePatchGroupState(args, optionsOrCb, cb) {
-        const command = new DescribePatchGroupStateCommand(args);
+    };
+    SSM.prototype.describePatchGroupState = function (args, optionsOrCb, cb) {
+        var command = new DescribePatchGroupStateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describePatchProperties(args, optionsOrCb, cb) {
-        const command = new DescribePatchPropertiesCommand(args);
+    };
+    SSM.prototype.describePatchProperties = function (args, optionsOrCb, cb) {
+        var command = new DescribePatchPropertiesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeSessions(args, optionsOrCb, cb) {
-        const command = new DescribeSessionsCommand(args);
+    };
+    SSM.prototype.describeSessions = function (args, optionsOrCb, cb) {
+        var command = new DescribeSessionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    disassociateOpsItemRelatedItem(args, optionsOrCb, cb) {
-        const command = new DisassociateOpsItemRelatedItemCommand(args);
+    };
+    SSM.prototype.disassociateOpsItemRelatedItem = function (args, optionsOrCb, cb) {
+        var command = new DisassociateOpsItemRelatedItemCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getAutomationExecution(args, optionsOrCb, cb) {
-        const command = new GetAutomationExecutionCommand(args);
+    };
+    SSM.prototype.getAutomationExecution = function (args, optionsOrCb, cb) {
+        var command = new GetAutomationExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCalendarState(args, optionsOrCb, cb) {
-        const command = new GetCalendarStateCommand(args);
+    };
+    SSM.prototype.getCalendarState = function (args, optionsOrCb, cb) {
+        var command = new GetCalendarStateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCommandInvocation(args, optionsOrCb, cb) {
-        const command = new GetCommandInvocationCommand(args);
+    };
+    SSM.prototype.getCommandInvocation = function (args, optionsOrCb, cb) {
+        var command = new GetCommandInvocationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getConnectionStatus(args, optionsOrCb, cb) {
-        const command = new GetConnectionStatusCommand(args);
+    };
+    SSM.prototype.getConnectionStatus = function (args, optionsOrCb, cb) {
+        var command = new GetConnectionStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDefaultPatchBaseline(args, optionsOrCb, cb) {
-        const command = new GetDefaultPatchBaselineCommand(args);
+    };
+    SSM.prototype.getDefaultPatchBaseline = function (args, optionsOrCb, cb) {
+        var command = new GetDefaultPatchBaselineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDeployablePatchSnapshotForInstance(args, optionsOrCb, cb) {
-        const command = new GetDeployablePatchSnapshotForInstanceCommand(args);
+    };
+    SSM.prototype.getDeployablePatchSnapshotForInstance = function (args, optionsOrCb, cb) {
+        var command = new GetDeployablePatchSnapshotForInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDocument(args, optionsOrCb, cb) {
-        const command = new GetDocumentCommand(args);
+    };
+    SSM.prototype.getDocument = function (args, optionsOrCb, cb) {
+        var command = new GetDocumentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getInventory(args, optionsOrCb, cb) {
-        const command = new GetInventoryCommand(args);
+    };
+    SSM.prototype.getInventory = function (args, optionsOrCb, cb) {
+        var command = new GetInventoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getInventorySchema(args, optionsOrCb, cb) {
-        const command = new GetInventorySchemaCommand(args);
+    };
+    SSM.prototype.getInventorySchema = function (args, optionsOrCb, cb) {
+        var command = new GetInventorySchemaCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMaintenanceWindow(args, optionsOrCb, cb) {
-        const command = new GetMaintenanceWindowCommand(args);
+    };
+    SSM.prototype.getMaintenanceWindow = function (args, optionsOrCb, cb) {
+        var command = new GetMaintenanceWindowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMaintenanceWindowExecution(args, optionsOrCb, cb) {
-        const command = new GetMaintenanceWindowExecutionCommand(args);
+    };
+    SSM.prototype.getMaintenanceWindowExecution = function (args, optionsOrCb, cb) {
+        var command = new GetMaintenanceWindowExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMaintenanceWindowExecutionTask(args, optionsOrCb, cb) {
-        const command = new GetMaintenanceWindowExecutionTaskCommand(args);
+    };
+    SSM.prototype.getMaintenanceWindowExecutionTask = function (args, optionsOrCb, cb) {
+        var command = new GetMaintenanceWindowExecutionTaskCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMaintenanceWindowExecutionTaskInvocation(args, optionsOrCb, cb) {
-        const command = new GetMaintenanceWindowExecutionTaskInvocationCommand(args);
+    };
+    SSM.prototype.getMaintenanceWindowExecutionTaskInvocation = function (args, optionsOrCb, cb) {
+        var command = new GetMaintenanceWindowExecutionTaskInvocationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMaintenanceWindowTask(args, optionsOrCb, cb) {
-        const command = new GetMaintenanceWindowTaskCommand(args);
+    };
+    SSM.prototype.getMaintenanceWindowTask = function (args, optionsOrCb, cb) {
+        var command = new GetMaintenanceWindowTaskCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getOpsItem(args, optionsOrCb, cb) {
-        const command = new GetOpsItemCommand(args);
+    };
+    SSM.prototype.getOpsItem = function (args, optionsOrCb, cb) {
+        var command = new GetOpsItemCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getOpsMetadata(args, optionsOrCb, cb) {
-        const command = new GetOpsMetadataCommand(args);
+    };
+    SSM.prototype.getOpsMetadata = function (args, optionsOrCb, cb) {
+        var command = new GetOpsMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getOpsSummary(args, optionsOrCb, cb) {
-        const command = new GetOpsSummaryCommand(args);
+    };
+    SSM.prototype.getOpsSummary = function (args, optionsOrCb, cb) {
+        var command = new GetOpsSummaryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getParameter(args, optionsOrCb, cb) {
-        const command = new GetParameterCommand(args);
+    };
+    SSM.prototype.getParameter = function (args, optionsOrCb, cb) {
+        var command = new GetParameterCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getParameterHistory(args, optionsOrCb, cb) {
-        const command = new GetParameterHistoryCommand(args);
+    };
+    SSM.prototype.getParameterHistory = function (args, optionsOrCb, cb) {
+        var command = new GetParameterHistoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getParameters(args, optionsOrCb, cb) {
-        const command = new GetParametersCommand(args);
+    };
+    SSM.prototype.getParameters = function (args, optionsOrCb, cb) {
+        var command = new GetParametersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getParametersByPath(args, optionsOrCb, cb) {
-        const command = new GetParametersByPathCommand(args);
+    };
+    SSM.prototype.getParametersByPath = function (args, optionsOrCb, cb) {
+        var command = new GetParametersByPathCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getPatchBaseline(args, optionsOrCb, cb) {
-        const command = new GetPatchBaselineCommand(args);
+    };
+    SSM.prototype.getPatchBaseline = function (args, optionsOrCb, cb) {
+        var command = new GetPatchBaselineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getPatchBaselineForPatchGroup(args, optionsOrCb, cb) {
-        const command = new GetPatchBaselineForPatchGroupCommand(args);
+    };
+    SSM.prototype.getPatchBaselineForPatchGroup = function (args, optionsOrCb, cb) {
+        var command = new GetPatchBaselineForPatchGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getServiceSetting(args, optionsOrCb, cb) {
-        const command = new GetServiceSettingCommand(args);
+    };
+    SSM.prototype.getServiceSetting = function (args, optionsOrCb, cb) {
+        var command = new GetServiceSettingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    labelParameterVersion(args, optionsOrCb, cb) {
-        const command = new LabelParameterVersionCommand(args);
+    };
+    SSM.prototype.labelParameterVersion = function (args, optionsOrCb, cb) {
+        var command = new LabelParameterVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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);
+    };
+    SSM.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);
         }
-    }
-    listAssociationVersions(args, optionsOrCb, cb) {
-        const command = new ListAssociationVersionsCommand(args);
+    };
+    SSM.prototype.listAssociationVersions = function (args, optionsOrCb, cb) {
+        var command = new ListAssociationVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listCommandInvocations(args, optionsOrCb, cb) {
-        const command = new ListCommandInvocationsCommand(args);
+    };
+    SSM.prototype.listCommandInvocations = function (args, optionsOrCb, cb) {
+        var command = new ListCommandInvocationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listCommands(args, optionsOrCb, cb) {
-        const command = new ListCommandsCommand(args);
+    };
+    SSM.prototype.listCommands = function (args, optionsOrCb, cb) {
+        var command = new ListCommandsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listComplianceItems(args, optionsOrCb, cb) {
-        const command = new ListComplianceItemsCommand(args);
+    };
+    SSM.prototype.listComplianceItems = function (args, optionsOrCb, cb) {
+        var command = new ListComplianceItemsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listComplianceSummaries(args, optionsOrCb, cb) {
-        const command = new ListComplianceSummariesCommand(args);
+    };
+    SSM.prototype.listComplianceSummaries = function (args, optionsOrCb, cb) {
+        var command = new ListComplianceSummariesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDocumentMetadataHistory(args, optionsOrCb, cb) {
-        const command = new ListDocumentMetadataHistoryCommand(args);
+    };
+    SSM.prototype.listDocumentMetadataHistory = function (args, optionsOrCb, cb) {
+        var command = new ListDocumentMetadataHistoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDocuments(args, optionsOrCb, cb) {
-        const command = new ListDocumentsCommand(args);
+    };
+    SSM.prototype.listDocuments = function (args, optionsOrCb, cb) {
+        var command = new ListDocumentsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDocumentVersions(args, optionsOrCb, cb) {
-        const command = new ListDocumentVersionsCommand(args);
+    };
+    SSM.prototype.listDocumentVersions = function (args, optionsOrCb, cb) {
+        var command = new ListDocumentVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listInventoryEntries(args, optionsOrCb, cb) {
-        const command = new ListInventoryEntriesCommand(args);
+    };
+    SSM.prototype.listInventoryEntries = function (args, optionsOrCb, cb) {
+        var command = new ListInventoryEntriesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listOpsItemEvents(args, optionsOrCb, cb) {
-        const command = new ListOpsItemEventsCommand(args);
+    };
+    SSM.prototype.listOpsItemEvents = function (args, optionsOrCb, cb) {
+        var command = new ListOpsItemEventsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listOpsItemRelatedItems(args, optionsOrCb, cb) {
-        const command = new ListOpsItemRelatedItemsCommand(args);
+    };
+    SSM.prototype.listOpsItemRelatedItems = function (args, optionsOrCb, cb) {
+        var command = new ListOpsItemRelatedItemsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listOpsMetadata(args, optionsOrCb, cb) {
-        const command = new ListOpsMetadataCommand(args);
+    };
+    SSM.prototype.listOpsMetadata = function (args, optionsOrCb, cb) {
+        var command = new ListOpsMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listResourceComplianceSummaries(args, optionsOrCb, cb) {
-        const command = new ListResourceComplianceSummariesCommand(args);
+    };
+    SSM.prototype.listResourceComplianceSummaries = function (args, optionsOrCb, cb) {
+        var command = new ListResourceComplianceSummariesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listResourceDataSync(args, optionsOrCb, cb) {
-        const command = new ListResourceDataSyncCommand(args);
+    };
+    SSM.prototype.listResourceDataSync = function (args, optionsOrCb, cb) {
+        var command = new ListResourceDataSyncCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTagsForResource(args, optionsOrCb, cb) {
-        const command = new ListTagsForResourceCommand(args);
+    };
+    SSM.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
+        var command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    modifyDocumentPermission(args, optionsOrCb, cb) {
-        const command = new ModifyDocumentPermissionCommand(args);
+    };
+    SSM.prototype.modifyDocumentPermission = function (args, optionsOrCb, cb) {
+        var command = new ModifyDocumentPermissionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putComplianceItems(args, optionsOrCb, cb) {
-        const command = new PutComplianceItemsCommand(args);
+    };
+    SSM.prototype.putComplianceItems = function (args, optionsOrCb, cb) {
+        var command = new PutComplianceItemsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putInventory(args, optionsOrCb, cb) {
-        const command = new PutInventoryCommand(args);
+    };
+    SSM.prototype.putInventory = function (args, optionsOrCb, cb) {
+        var command = new PutInventoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putParameter(args, optionsOrCb, cb) {
-        const command = new PutParameterCommand(args);
+    };
+    SSM.prototype.putParameter = function (args, optionsOrCb, cb) {
+        var command = new PutParameterCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    registerDefaultPatchBaseline(args, optionsOrCb, cb) {
-        const command = new RegisterDefaultPatchBaselineCommand(args);
+    };
+    SSM.prototype.registerDefaultPatchBaseline = function (args, optionsOrCb, cb) {
+        var command = new RegisterDefaultPatchBaselineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    registerPatchBaselineForPatchGroup(args, optionsOrCb, cb) {
-        const command = new RegisterPatchBaselineForPatchGroupCommand(args);
+    };
+    SSM.prototype.registerPatchBaselineForPatchGroup = function (args, optionsOrCb, cb) {
+        var command = new RegisterPatchBaselineForPatchGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    registerTargetWithMaintenanceWindow(args, optionsOrCb, cb) {
-        const command = new RegisterTargetWithMaintenanceWindowCommand(args);
+    };
+    SSM.prototype.registerTargetWithMaintenanceWindow = function (args, optionsOrCb, cb) {
+        var command = new RegisterTargetWithMaintenanceWindowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    registerTaskWithMaintenanceWindow(args, optionsOrCb, cb) {
-        const command = new RegisterTaskWithMaintenanceWindowCommand(args);
+    };
+    SSM.prototype.registerTaskWithMaintenanceWindow = function (args, optionsOrCb, cb) {
+        var command = new RegisterTaskWithMaintenanceWindowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    removeTagsFromResource(args, optionsOrCb, cb) {
-        const command = new RemoveTagsFromResourceCommand(args);
+    };
+    SSM.prototype.removeTagsFromResource = function (args, optionsOrCb, cb) {
+        var command = new RemoveTagsFromResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    resetServiceSetting(args, optionsOrCb, cb) {
-        const command = new ResetServiceSettingCommand(args);
+    };
+    SSM.prototype.resetServiceSetting = function (args, optionsOrCb, cb) {
+        var command = new ResetServiceSettingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    resumeSession(args, optionsOrCb, cb) {
-        const command = new ResumeSessionCommand(args);
+    };
+    SSM.prototype.resumeSession = function (args, optionsOrCb, cb) {
+        var command = new ResumeSessionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    sendAutomationSignal(args, optionsOrCb, cb) {
-        const command = new SendAutomationSignalCommand(args);
+    };
+    SSM.prototype.sendAutomationSignal = function (args, optionsOrCb, cb) {
+        var command = new SendAutomationSignalCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    sendCommand(args, optionsOrCb, cb) {
-        const command = new SendCommandCommand(args);
+    };
+    SSM.prototype.sendCommand = function (args, optionsOrCb, cb) {
+        var command = new SendCommandCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startAssociationsOnce(args, optionsOrCb, cb) {
-        const command = new StartAssociationsOnceCommand(args);
+    };
+    SSM.prototype.startAssociationsOnce = function (args, optionsOrCb, cb) {
+        var command = new StartAssociationsOnceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startAutomationExecution(args, optionsOrCb, cb) {
-        const command = new StartAutomationExecutionCommand(args);
+    };
+    SSM.prototype.startAutomationExecution = function (args, optionsOrCb, cb) {
+        var command = new StartAutomationExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startChangeRequestExecution(args, optionsOrCb, cb) {
-        const command = new StartChangeRequestExecutionCommand(args);
+    };
+    SSM.prototype.startChangeRequestExecution = function (args, optionsOrCb, cb) {
+        var command = new StartChangeRequestExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startSession(args, optionsOrCb, cb) {
-        const command = new StartSessionCommand(args);
+    };
+    SSM.prototype.startSession = function (args, optionsOrCb, cb) {
+        var command = new StartSessionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopAutomationExecution(args, optionsOrCb, cb) {
-        const command = new StopAutomationExecutionCommand(args);
+    };
+    SSM.prototype.stopAutomationExecution = function (args, optionsOrCb, cb) {
+        var command = new StopAutomationExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    terminateSession(args, optionsOrCb, cb) {
-        const command = new TerminateSessionCommand(args);
+    };
+    SSM.prototype.terminateSession = function (args, optionsOrCb, cb) {
+        var command = new TerminateSessionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    unlabelParameterVersion(args, optionsOrCb, cb) {
-        const command = new UnlabelParameterVersionCommand(args);
+    };
+    SSM.prototype.unlabelParameterVersion = function (args, optionsOrCb, cb) {
+        var command = new UnlabelParameterVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateAssociation(args, optionsOrCb, cb) {
-        const command = new UpdateAssociationCommand(args);
+    };
+    SSM.prototype.updateAssociation = function (args, optionsOrCb, cb) {
+        var command = new UpdateAssociationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateAssociationStatus(args, optionsOrCb, cb) {
-        const command = new UpdateAssociationStatusCommand(args);
+    };
+    SSM.prototype.updateAssociationStatus = function (args, optionsOrCb, cb) {
+        var command = new UpdateAssociationStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDocument(args, optionsOrCb, cb) {
-        const command = new UpdateDocumentCommand(args);
+    };
+    SSM.prototype.updateDocument = function (args, optionsOrCb, cb) {
+        var command = new UpdateDocumentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDocumentDefaultVersion(args, optionsOrCb, cb) {
-        const command = new UpdateDocumentDefaultVersionCommand(args);
+    };
+    SSM.prototype.updateDocumentDefaultVersion = function (args, optionsOrCb, cb) {
+        var command = new UpdateDocumentDefaultVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDocumentMetadata(args, optionsOrCb, cb) {
-        const command = new UpdateDocumentMetadataCommand(args);
+    };
+    SSM.prototype.updateDocumentMetadata = function (args, optionsOrCb, cb) {
+        var command = new UpdateDocumentMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateMaintenanceWindow(args, optionsOrCb, cb) {
-        const command = new UpdateMaintenanceWindowCommand(args);
+    };
+    SSM.prototype.updateMaintenanceWindow = function (args, optionsOrCb, cb) {
+        var command = new UpdateMaintenanceWindowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateMaintenanceWindowTarget(args, optionsOrCb, cb) {
-        const command = new UpdateMaintenanceWindowTargetCommand(args);
+    };
+    SSM.prototype.updateMaintenanceWindowTarget = function (args, optionsOrCb, cb) {
+        var command = new UpdateMaintenanceWindowTargetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateMaintenanceWindowTask(args, optionsOrCb, cb) {
-        const command = new UpdateMaintenanceWindowTaskCommand(args);
+    };
+    SSM.prototype.updateMaintenanceWindowTask = function (args, optionsOrCb, cb) {
+        var command = new UpdateMaintenanceWindowTaskCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateManagedInstanceRole(args, optionsOrCb, cb) {
-        const command = new UpdateManagedInstanceRoleCommand(args);
+    };
+    SSM.prototype.updateManagedInstanceRole = function (args, optionsOrCb, cb) {
+        var command = new UpdateManagedInstanceRoleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateOpsItem(args, optionsOrCb, cb) {
-        const command = new UpdateOpsItemCommand(args);
+    };
+    SSM.prototype.updateOpsItem = function (args, optionsOrCb, cb) {
+        var command = new UpdateOpsItemCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateOpsMetadata(args, optionsOrCb, cb) {
-        const command = new UpdateOpsMetadataCommand(args);
+    };
+    SSM.prototype.updateOpsMetadata = function (args, optionsOrCb, cb) {
+        var command = new UpdateOpsMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updatePatchBaseline(args, optionsOrCb, cb) {
-        const command = new UpdatePatchBaselineCommand(args);
+    };
+    SSM.prototype.updatePatchBaseline = function (args, optionsOrCb, cb) {
+        var command = new UpdatePatchBaselineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateResourceDataSync(args, optionsOrCb, cb) {
-        const command = new UpdateResourceDataSyncCommand(args);
+    };
+    SSM.prototype.updateResourceDataSync = function (args, optionsOrCb, cb) {
+        var command = new UpdateResourceDataSyncCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateServiceSetting(args, optionsOrCb, cb) {
-        const command = new UpdateServiceSettingCommand(args);
+    };
+    SSM.prototype.updateServiceSetting = function (args, optionsOrCb, cb) {
+        var command = new UpdateServiceSettingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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 SSM;
+}(SSMClient));
+export { SSM };