@aws-sdk/client-kafka 3.40.0 → 3.44.0

package/dist-es/Kafka.js

@@ -2,17 +2,20 @@ import { __extends } from "tslib";
 import { BatchAssociateScramSecretCommand, } from "./commands/BatchAssociateScramSecretCommand";
 import { BatchDisassociateScramSecretCommand, } from "./commands/BatchDisassociateScramSecretCommand";
 import { CreateClusterCommand, } from "./commands/CreateClusterCommand";
+import { CreateClusterV2Command, } from "./commands/CreateClusterV2Command";
 import { CreateConfigurationCommand, } from "./commands/CreateConfigurationCommand";
 import { DeleteClusterCommand, } from "./commands/DeleteClusterCommand";
 import { DeleteConfigurationCommand, } from "./commands/DeleteConfigurationCommand";
 import { DescribeClusterCommand, } from "./commands/DescribeClusterCommand";
 import { DescribeClusterOperationCommand, } from "./commands/DescribeClusterOperationCommand";
+import { DescribeClusterV2Command, } from "./commands/DescribeClusterV2Command";
 import { DescribeConfigurationCommand, } from "./commands/DescribeConfigurationCommand";
 import { DescribeConfigurationRevisionCommand, } from "./commands/DescribeConfigurationRevisionCommand";
 import { GetBootstrapBrokersCommand, } from "./commands/GetBootstrapBrokersCommand";
 import { GetCompatibleKafkaVersionsCommand, } from "./commands/GetCompatibleKafkaVersionsCommand";
 import { ListClusterOperationsCommand, } from "./commands/ListClusterOperationsCommand";
 import { ListClustersCommand, } from "./commands/ListClustersCommand";
+import { ListClustersV2Command, } from "./commands/ListClustersV2Command";
 import { ListConfigurationRevisionsCommand, } from "./commands/ListConfigurationRevisionsCommand";
 import { ListConfigurationsCommand, } from "./commands/ListConfigurationsCommand";
 import { ListKafkaVersionsCommand, } from "./commands/ListKafkaVersionsCommand";
@@ -28,6 +31,7 @@ import { UpdateBrokerTypeCommand, } from "./commands/UpdateBrokerTypeCommand";
 import { UpdateClusterConfigurationCommand, } from "./commands/UpdateClusterConfigurationCommand";
 import { UpdateClusterKafkaVersionCommand, } from "./commands/UpdateClusterKafkaVersionCommand";
 import { UpdateConfigurationCommand, } from "./commands/UpdateConfigurationCommand";
+import { UpdateConnectivityCommand, } from "./commands/UpdateConnectivityCommand";
 import { UpdateMonitoringCommand, } from "./commands/UpdateMonitoringCommand";
 import { UpdateSecurityCommand, } from "./commands/UpdateSecurityCommand";
 import { KafkaClient } from "./KafkaClient";
@@ -78,6 +82,20 @@ var Kafka = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Kafka.prototype.createConfiguration = function (args, optionsOrCb, cb) {
         var command = new CreateConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -148,6 +166,20 @@ var Kafka = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Kafka.prototype.describeConfiguration = function (args, optionsOrCb, cb) {
         var command = new DescribeConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -232,6 +264,20 @@ var Kafka = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Kafka.prototype.listConfigurationRevisions = function (args, optionsOrCb, cb) {
         var command = new ListConfigurationRevisionsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -442,6 +488,20 @@ var Kafka = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Kafka.prototype.updateMonitoring = function (args, optionsOrCb, cb) {
         var command = new UpdateMonitoringCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/CreateClusterV2Command.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateClusterV2Request, CreateClusterV2Response } from "../models/models_0";
+import { deserializeAws_restJson1CreateClusterV2Command, serializeAws_restJson1CreateClusterV2Command, } from "../protocols/Aws_restJson1";
+var CreateClusterV2Command = (function (_super) {
+    __extends(CreateClusterV2Command, _super);
+    function CreateClusterV2Command(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateClusterV2Command.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KafkaClient";
+        var commandName = "CreateClusterV2Command";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateClusterV2Request.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateClusterV2Response.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateClusterV2Command.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateClusterV2Command(input, context);
+    };
+    CreateClusterV2Command.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateClusterV2Command(output, context);
+    };
+    return CreateClusterV2Command;
+}($Command));
+export { CreateClusterV2Command };

package/dist-es/commands/DescribeClusterV2Command.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DescribeClusterV2Request, DescribeClusterV2Response } from "../models/models_0";
+import { deserializeAws_restJson1DescribeClusterV2Command, serializeAws_restJson1DescribeClusterV2Command, } from "../protocols/Aws_restJson1";
+var DescribeClusterV2Command = (function (_super) {
+    __extends(DescribeClusterV2Command, _super);
+    function DescribeClusterV2Command(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeClusterV2Command.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KafkaClient";
+        var commandName = "DescribeClusterV2Command";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeClusterV2Request.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeClusterV2Response.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeClusterV2Command.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DescribeClusterV2Command(input, context);
+    };
+    DescribeClusterV2Command.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DescribeClusterV2Command(output, context);
+    };
+    return DescribeClusterV2Command;
+}($Command));
+export { DescribeClusterV2Command };

package/dist-es/commands/ListClustersV2Command.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListClustersV2Request, ListClustersV2Response } from "../models/models_0";
+import { deserializeAws_restJson1ListClustersV2Command, serializeAws_restJson1ListClustersV2Command, } from "../protocols/Aws_restJson1";
+var ListClustersV2Command = (function (_super) {
+    __extends(ListClustersV2Command, _super);
+    function ListClustersV2Command(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListClustersV2Command.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KafkaClient";
+        var commandName = "ListClustersV2Command";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListClustersV2Request.filterSensitiveLog,
+            outputFilterSensitiveLog: ListClustersV2Response.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListClustersV2Command.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListClustersV2Command(input, context);
+    };
+    ListClustersV2Command.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListClustersV2Command(output, context);
+    };
+    return ListClustersV2Command;
+}($Command));
+export { ListClustersV2Command };

package/dist-es/commands/UpdateConnectivityCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateConnectivityRequest, UpdateConnectivityResponse } from "../models/models_0";
+import { deserializeAws_restJson1UpdateConnectivityCommand, serializeAws_restJson1UpdateConnectivityCommand, } from "../protocols/Aws_restJson1";
+var UpdateConnectivityCommand = (function (_super) {
+    __extends(UpdateConnectivityCommand, _super);
+    function UpdateConnectivityCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateConnectivityCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KafkaClient";
+        var commandName = "UpdateConnectivityCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateConnectivityRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateConnectivityResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateConnectivityCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateConnectivityCommand(input, context);
+    };
+    UpdateConnectivityCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateConnectivityCommand(output, context);
+    };
+    return UpdateConnectivityCommand;
+}($Command));
+export { UpdateConnectivityCommand };

package/dist-es/commands/index.js

@@ -1,17 +1,20 @@
 export * from "./BatchAssociateScramSecretCommand";
 export * from "./BatchDisassociateScramSecretCommand";
 export * from "./CreateClusterCommand";
+export * from "./CreateClusterV2Command";
 export * from "./CreateConfigurationCommand";
 export * from "./DeleteClusterCommand";
 export * from "./DeleteConfigurationCommand";
 export * from "./DescribeClusterCommand";
 export * from "./DescribeClusterOperationCommand";
+export * from "./DescribeClusterV2Command";
 export * from "./DescribeConfigurationCommand";
 export * from "./DescribeConfigurationRevisionCommand";
 export * from "./GetBootstrapBrokersCommand";
 export * from "./GetCompatibleKafkaVersionsCommand";
 export * from "./ListClusterOperationsCommand";
 export * from "./ListClustersCommand";
+export * from "./ListClustersV2Command";
 export * from "./ListConfigurationRevisionsCommand";
 export * from "./ListConfigurationsCommand";
 export * from "./ListKafkaVersionsCommand";
@@ -27,5 +30,6 @@ export * from "./UpdateBrokerTypeCommand";
 export * from "./UpdateClusterConfigurationCommand";
 export * from "./UpdateClusterKafkaVersionCommand";
 export * from "./UpdateConfigurationCommand";
+export * from "./UpdateConnectivityCommand";
 export * from "./UpdateMonitoringCommand";
 export * from "./UpdateSecurityCommand";

package/dist-es/endpoints.js

@@ -76,6 +76,10 @@ var partitionHash = {
                 hostname: "kafka.{region}.c2s.ic.gov",
                 tags: [],
             },
+            {
+                hostname: "kafka-fips.{region}.c2s.ic.gov",
+                tags: ["fips"],
+            },
         ],
     },
     "aws-iso-b": {
@@ -86,6 +90,10 @@ var partitionHash = {
                 hostname: "kafka.{region}.sc2s.sgov.gov",
                 tags: [],
             },
+            {
+                hostname: "kafka-fips.{region}.sc2s.sgov.gov",
+                tags: ["fips"],
+            },
         ],
     },
     "aws-us-gov": {

package/dist-es/models/models_0.js

@@ -3,10 +3,23 @@ export var BrokerEBSVolumeInfo;
 (function (BrokerEBSVolumeInfo) {
     BrokerEBSVolumeInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(BrokerEBSVolumeInfo || (BrokerEBSVolumeInfo = {}));
+export var ClusterType;
+(function (ClusterType) {
+    ClusterType["PROVISIONED"] = "PROVISIONED";
+    ClusterType["SERVERLESS"] = "SERVERLESS";
+})(ClusterType || (ClusterType = {}));
 export var BrokerAZDistribution;
 (function (BrokerAZDistribution) {
     BrokerAZDistribution["DEFAULT"] = "DEFAULT";
 })(BrokerAZDistribution || (BrokerAZDistribution = {}));
+export var PublicAccess;
+(function (PublicAccess) {
+    PublicAccess.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PublicAccess || (PublicAccess = {}));
+export var ConnectivityInfo;
+(function (ConnectivityInfo) {
+    ConnectivityInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ConnectivityInfo || (ConnectivityInfo = {}));
 export var EBSStorageInfo;
 (function (EBSStorageInfo) {
     EBSStorageInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -92,6 +105,61 @@ export var LoggingInfo;
 (function (LoggingInfo) {
     LoggingInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(LoggingInfo || (LoggingInfo = {}));
+export var JmxExporterInfo;
+(function (JmxExporterInfo) {
+    JmxExporterInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(JmxExporterInfo || (JmxExporterInfo = {}));
+export var NodeExporterInfo;
+(function (NodeExporterInfo) {
+    NodeExporterInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(NodeExporterInfo || (NodeExporterInfo = {}));
+export var PrometheusInfo;
+(function (PrometheusInfo) {
+    PrometheusInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PrometheusInfo || (PrometheusInfo = {}));
+export var OpenMonitoringInfo;
+(function (OpenMonitoringInfo) {
+    OpenMonitoringInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(OpenMonitoringInfo || (OpenMonitoringInfo = {}));
+export var Provisioned;
+(function (Provisioned) {
+    Provisioned.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Provisioned || (Provisioned = {}));
+export var ServerlessSasl;
+(function (ServerlessSasl) {
+    ServerlessSasl.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ServerlessSasl || (ServerlessSasl = {}));
+export var ServerlessClientAuthentication;
+(function (ServerlessClientAuthentication) {
+    ServerlessClientAuthentication.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ServerlessClientAuthentication || (ServerlessClientAuthentication = {}));
+export var VpcConfig;
+(function (VpcConfig) {
+    VpcConfig.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(VpcConfig || (VpcConfig = {}));
+export var Serverless;
+(function (Serverless) {
+    Serverless.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Serverless || (Serverless = {}));
+export var ClusterState;
+(function (ClusterState) {
+    ClusterState["ACTIVE"] = "ACTIVE";
+    ClusterState["CREATING"] = "CREATING";
+    ClusterState["DELETING"] = "DELETING";
+    ClusterState["FAILED"] = "FAILED";
+    ClusterState["HEALING"] = "HEALING";
+    ClusterState["MAINTENANCE"] = "MAINTENANCE";
+    ClusterState["REBOOTING_BROKER"] = "REBOOTING_BROKER";
+    ClusterState["UPDATING"] = "UPDATING";
+})(ClusterState || (ClusterState = {}));
+export var StateInfo;
+(function (StateInfo) {
+    StateInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(StateInfo || (StateInfo = {}));
+export var Cluster;
+(function (Cluster) {
+    Cluster.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Cluster || (Cluster = {}));
 export var JmxExporter;
 (function (JmxExporter) {
     JmxExporter.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -108,21 +176,6 @@ export var OpenMonitoring;
 (function (OpenMonitoring) {
     OpenMonitoring.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(OpenMonitoring || (OpenMonitoring = {}));
-export var ClusterState;
-(function (ClusterState) {
-    ClusterState["ACTIVE"] = "ACTIVE";
-    ClusterState["CREATING"] = "CREATING";
-    ClusterState["DELETING"] = "DELETING";
-    ClusterState["FAILED"] = "FAILED";
-    ClusterState["HEALING"] = "HEALING";
-    ClusterState["MAINTENANCE"] = "MAINTENANCE";
-    ClusterState["REBOOTING_BROKER"] = "REBOOTING_BROKER";
-    ClusterState["UPDATING"] = "UPDATING";
-})(ClusterState || (ClusterState = {}));
-export var StateInfo;
-(function (StateInfo) {
-    StateInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-})(StateInfo || (StateInfo = {}));
 export var ClusterInfo;
 (function (ClusterInfo) {
     ClusterInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -246,22 +299,6 @@ export var ConflictException;
 (function (ConflictException) {
     ConflictException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(ConflictException || (ConflictException = {}));
-export var JmxExporterInfo;
-(function (JmxExporterInfo) {
-    JmxExporterInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-})(JmxExporterInfo || (JmxExporterInfo = {}));
-export var NodeExporterInfo;
-(function (NodeExporterInfo) {
-    NodeExporterInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-})(NodeExporterInfo || (NodeExporterInfo = {}));
-export var PrometheusInfo;
-(function (PrometheusInfo) {
-    PrometheusInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-})(PrometheusInfo || (PrometheusInfo = {}));
-export var OpenMonitoringInfo;
-(function (OpenMonitoringInfo) {
-    OpenMonitoringInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-})(OpenMonitoringInfo || (OpenMonitoringInfo = {}));
 export var CreateClusterRequest;
 (function (CreateClusterRequest) {
     CreateClusterRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -270,6 +307,22 @@ export var CreateClusterResponse;
 (function (CreateClusterResponse) {
     CreateClusterResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(CreateClusterResponse || (CreateClusterResponse = {}));
+export var ProvisionedRequest;
+(function (ProvisionedRequest) {
+    ProvisionedRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ProvisionedRequest || (ProvisionedRequest = {}));
+export var ServerlessRequest;
+(function (ServerlessRequest) {
+    ServerlessRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ServerlessRequest || (ServerlessRequest = {}));
+export var CreateClusterV2Request;
+(function (CreateClusterV2Request) {
+    CreateClusterV2Request.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateClusterV2Request || (CreateClusterV2Request = {}));
+export var CreateClusterV2Response;
+(function (CreateClusterV2Response) {
+    CreateClusterV2Response.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateClusterV2Response || (CreateClusterV2Response = {}));
 export var CreateConfigurationRequest;
 (function (CreateConfigurationRequest) {
     CreateConfigurationRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -310,6 +363,14 @@ export var DescribeClusterOperationResponse;
 (function (DescribeClusterOperationResponse) {
     DescribeClusterOperationResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(DescribeClusterOperationResponse || (DescribeClusterOperationResponse = {}));
+export var DescribeClusterV2Request;
+(function (DescribeClusterV2Request) {
+    DescribeClusterV2Request.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeClusterV2Request || (DescribeClusterV2Request = {}));
+export var DescribeClusterV2Response;
+(function (DescribeClusterV2Response) {
+    DescribeClusterV2Response.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeClusterV2Response || (DescribeClusterV2Response = {}));
 export var DescribeConfigurationRequest;
 (function (DescribeConfigurationRequest) {
     DescribeConfigurationRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -358,6 +419,14 @@ export var ListClustersResponse;
 (function (ListClustersResponse) {
     ListClustersResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(ListClustersResponse || (ListClustersResponse = {}));
+export var ListClustersV2Request;
+(function (ListClustersV2Request) {
+    ListClustersV2Request.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListClustersV2Request || (ListClustersV2Request = {}));
+export var ListClustersV2Response;
+(function (ListClustersV2Response) {
+    ListClustersV2Response.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListClustersV2Response || (ListClustersV2Response = {}));
 export var ListConfigurationRevisionsRequest;
 (function (ListConfigurationRevisionsRequest) {
     ListConfigurationRevisionsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -470,6 +539,14 @@ export var UpdateConfigurationResponse;
 (function (UpdateConfigurationResponse) {
     UpdateConfigurationResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(UpdateConfigurationResponse || (UpdateConfigurationResponse = {}));
+export var UpdateConnectivityRequest;
+(function (UpdateConnectivityRequest) {
+    UpdateConnectivityRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateConnectivityRequest || (UpdateConnectivityRequest = {}));
+export var UpdateConnectivityResponse;
+(function (UpdateConnectivityResponse) {
+    UpdateConnectivityResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateConnectivityResponse || (UpdateConnectivityResponse = {}));
 export var UpdateMonitoringRequest;
 (function (UpdateMonitoringRequest) {
     UpdateMonitoringRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };

package/dist-es/pagination/ListClustersV2Paginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListClustersV2Command, } from "../commands/ListClustersV2Command";
+import { Kafka } from "../Kafka";
+import { KafkaClient } from "../KafkaClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListClustersV2Command(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.listClustersV2.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListClustersV2(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListClustersV2_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.NextToken = token;
+                    input["MaxResults"] = config.pageSize;
+                    if (!(config.client instanceof Kafka)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof KafkaClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected Kafka | KafkaClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.NextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/index.js

@@ -1,6 +1,7 @@
 export * from "./Interfaces";
 export * from "./ListClusterOperationsPaginator";
 export * from "./ListClustersPaginator";
+export * from "./ListClustersV2Paginator";
 export * from "./ListConfigurationRevisionsPaginator";
 export * from "./ListConfigurationsPaginator";
 export * from "./ListKafkaVersionsPaginator";