@aws-sdk/client-kafka 3.183.0 → 3.186.0

package/dist-es/Kafka.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { BatchAssociateScramSecretCommand, } from "./commands/BatchAssociateScramSecretCommand";
 import { BatchDisassociateScramSecretCommand, } from "./commands/BatchDisassociateScramSecretCommand";
 import { CreateClusterCommand, } from "./commands/CreateClusterCommand";
@@ -34,495 +35,501 @@ import { UpdateConnectivityCommand, } from "./commands/UpdateConnectivityCommand
 import { UpdateMonitoringCommand, } from "./commands/UpdateMonitoringCommand";
 import { UpdateSecurityCommand, } from "./commands/UpdateSecurityCommand";
 import { KafkaClient } from "./KafkaClient";
-export class Kafka extends KafkaClient {
-    batchAssociateScramSecret(args, optionsOrCb, cb) {
-        const command = new BatchAssociateScramSecretCommand(args);
+var Kafka = (function (_super) {
+    __extends(Kafka, _super);
+    function Kafka() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Kafka.prototype.batchAssociateScramSecret = function (args, optionsOrCb, cb) {
+        var command = new BatchAssociateScramSecretCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchDisassociateScramSecret(args, optionsOrCb, cb) {
-        const command = new BatchDisassociateScramSecretCommand(args);
+    };
+    Kafka.prototype.batchDisassociateScramSecret = function (args, optionsOrCb, cb) {
+        var command = new BatchDisassociateScramSecretCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createCluster(args, optionsOrCb, cb) {
-        const command = new CreateClusterCommand(args);
+    };
+    Kafka.prototype.createCluster = function (args, optionsOrCb, cb) {
+        var command = new CreateClusterCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createClusterV2(args, optionsOrCb, cb) {
-        const command = new CreateClusterV2Command(args);
+    };
+    Kafka.prototype.createClusterV2 = function (args, optionsOrCb, cb) {
+        var command = new CreateClusterV2Command(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createConfiguration(args, optionsOrCb, cb) {
-        const command = new CreateConfigurationCommand(args);
+    };
+    Kafka.prototype.createConfiguration = function (args, optionsOrCb, cb) {
+        var command = new CreateConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteCluster(args, optionsOrCb, cb) {
-        const command = new DeleteClusterCommand(args);
+    };
+    Kafka.prototype.deleteCluster = function (args, optionsOrCb, cb) {
+        var command = new DeleteClusterCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteConfiguration(args, optionsOrCb, cb) {
-        const command = new DeleteConfigurationCommand(args);
+    };
+    Kafka.prototype.deleteConfiguration = function (args, optionsOrCb, cb) {
+        var command = new DeleteConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeCluster(args, optionsOrCb, cb) {
-        const command = new DescribeClusterCommand(args);
+    };
+    Kafka.prototype.describeCluster = function (args, optionsOrCb, cb) {
+        var command = new DescribeClusterCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeClusterOperation(args, optionsOrCb, cb) {
-        const command = new DescribeClusterOperationCommand(args);
+    };
+    Kafka.prototype.describeClusterOperation = function (args, optionsOrCb, cb) {
+        var command = new DescribeClusterOperationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeClusterV2(args, optionsOrCb, cb) {
-        const command = new DescribeClusterV2Command(args);
+    };
+    Kafka.prototype.describeClusterV2 = function (args, optionsOrCb, cb) {
+        var command = new DescribeClusterV2Command(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeConfiguration(args, optionsOrCb, cb) {
-        const command = new DescribeConfigurationCommand(args);
+    };
+    Kafka.prototype.describeConfiguration = function (args, optionsOrCb, cb) {
+        var command = new DescribeConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeConfigurationRevision(args, optionsOrCb, cb) {
-        const command = new DescribeConfigurationRevisionCommand(args);
+    };
+    Kafka.prototype.describeConfigurationRevision = function (args, optionsOrCb, cb) {
+        var command = new DescribeConfigurationRevisionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBootstrapBrokers(args, optionsOrCb, cb) {
-        const command = new GetBootstrapBrokersCommand(args);
+    };
+    Kafka.prototype.getBootstrapBrokers = function (args, optionsOrCb, cb) {
+        var command = new GetBootstrapBrokersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCompatibleKafkaVersions(args, optionsOrCb, cb) {
-        const command = new GetCompatibleKafkaVersionsCommand(args);
+    };
+    Kafka.prototype.getCompatibleKafkaVersions = function (args, optionsOrCb, cb) {
+        var command = new GetCompatibleKafkaVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listClusterOperations(args, optionsOrCb, cb) {
-        const command = new ListClusterOperationsCommand(args);
+    };
+    Kafka.prototype.listClusterOperations = function (args, optionsOrCb, cb) {
+        var command = new ListClusterOperationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listClusters(args, optionsOrCb, cb) {
-        const command = new ListClustersCommand(args);
+    };
+    Kafka.prototype.listClusters = function (args, optionsOrCb, cb) {
+        var command = new ListClustersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listClustersV2(args, optionsOrCb, cb) {
-        const command = new ListClustersV2Command(args);
+    };
+    Kafka.prototype.listClustersV2 = function (args, optionsOrCb, cb) {
+        var command = new ListClustersV2Command(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listConfigurationRevisions(args, optionsOrCb, cb) {
-        const command = new ListConfigurationRevisionsCommand(args);
+    };
+    Kafka.prototype.listConfigurationRevisions = function (args, optionsOrCb, cb) {
+        var command = new ListConfigurationRevisionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listConfigurations(args, optionsOrCb, cb) {
-        const command = new ListConfigurationsCommand(args);
+    };
+    Kafka.prototype.listConfigurations = function (args, optionsOrCb, cb) {
+        var command = new ListConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listKafkaVersions(args, optionsOrCb, cb) {
-        const command = new ListKafkaVersionsCommand(args);
+    };
+    Kafka.prototype.listKafkaVersions = function (args, optionsOrCb, cb) {
+        var command = new ListKafkaVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listNodes(args, optionsOrCb, cb) {
-        const command = new ListNodesCommand(args);
+    };
+    Kafka.prototype.listNodes = function (args, optionsOrCb, cb) {
+        var command = new ListNodesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listScramSecrets(args, optionsOrCb, cb) {
-        const command = new ListScramSecretsCommand(args);
+    };
+    Kafka.prototype.listScramSecrets = function (args, optionsOrCb, cb) {
+        var command = new ListScramSecretsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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);
+    };
+    Kafka.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);
         }
-    }
-    rebootBroker(args, optionsOrCb, cb) {
-        const command = new RebootBrokerCommand(args);
+    };
+    Kafka.prototype.rebootBroker = function (args, optionsOrCb, cb) {
+        var command = new RebootBrokerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    tagResource(args, optionsOrCb, cb) {
-        const command = new TagResourceCommand(args);
+    };
+    Kafka.prototype.tagResource = function (args, optionsOrCb, cb) {
+        var command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    untagResource(args, optionsOrCb, cb) {
-        const command = new UntagResourceCommand(args);
+    };
+    Kafka.prototype.untagResource = function (args, optionsOrCb, cb) {
+        var command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateBrokerCount(args, optionsOrCb, cb) {
-        const command = new UpdateBrokerCountCommand(args);
+    };
+    Kafka.prototype.updateBrokerCount = function (args, optionsOrCb, cb) {
+        var command = new UpdateBrokerCountCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateBrokerStorage(args, optionsOrCb, cb) {
-        const command = new UpdateBrokerStorageCommand(args);
+    };
+    Kafka.prototype.updateBrokerStorage = function (args, optionsOrCb, cb) {
+        var command = new UpdateBrokerStorageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateBrokerType(args, optionsOrCb, cb) {
-        const command = new UpdateBrokerTypeCommand(args);
+    };
+    Kafka.prototype.updateBrokerType = function (args, optionsOrCb, cb) {
+        var command = new UpdateBrokerTypeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateClusterConfiguration(args, optionsOrCb, cb) {
-        const command = new UpdateClusterConfigurationCommand(args);
+    };
+    Kafka.prototype.updateClusterConfiguration = function (args, optionsOrCb, cb) {
+        var command = new UpdateClusterConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateClusterKafkaVersion(args, optionsOrCb, cb) {
-        const command = new UpdateClusterKafkaVersionCommand(args);
+    };
+    Kafka.prototype.updateClusterKafkaVersion = function (args, optionsOrCb, cb) {
+        var command = new UpdateClusterKafkaVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateConfiguration(args, optionsOrCb, cb) {
-        const command = new UpdateConfigurationCommand(args);
+    };
+    Kafka.prototype.updateConfiguration = function (args, optionsOrCb, cb) {
+        var command = new UpdateConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateConnectivity(args, optionsOrCb, cb) {
-        const command = new UpdateConnectivityCommand(args);
+    };
+    Kafka.prototype.updateConnectivity = function (args, optionsOrCb, cb) {
+        var command = new UpdateConnectivityCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateMonitoring(args, optionsOrCb, cb) {
-        const command = new UpdateMonitoringCommand(args);
+    };
+    Kafka.prototype.updateMonitoring = function (args, optionsOrCb, cb) {
+        var command = new UpdateMonitoringCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateSecurity(args, optionsOrCb, cb) {
-        const command = new UpdateSecurityCommand(args);
+    };
+    Kafka.prototype.updateSecurity = function (args, optionsOrCb, cb) {
+        var command = new UpdateSecurityCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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 Kafka;
+}(KafkaClient));
+export { Kafka };