@aws-sdk/client-kafka 3.321.1 → 3.322.0

package/dist-es/Kafka.js

@@ -4,15 +4,21 @@ import { BatchDisassociateScramSecretCommand, } from "./commands/BatchDisassocia
 import { CreateClusterCommand, } from "./commands/CreateClusterCommand";
 import { CreateClusterV2Command, } from "./commands/CreateClusterV2Command";
 import { CreateConfigurationCommand, } from "./commands/CreateConfigurationCommand";
+import { CreateVpcConnectionCommand, } from "./commands/CreateVpcConnectionCommand";
 import { DeleteClusterCommand, } from "./commands/DeleteClusterCommand";
+import { DeleteClusterPolicyCommand, } from "./commands/DeleteClusterPolicyCommand";
 import { DeleteConfigurationCommand, } from "./commands/DeleteConfigurationCommand";
+import { DeleteVpcConnectionCommand, } from "./commands/DeleteVpcConnectionCommand";
 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 { DescribeVpcConnectionCommand, } from "./commands/DescribeVpcConnectionCommand";
 import { GetBootstrapBrokersCommand, } from "./commands/GetBootstrapBrokersCommand";
+import { GetClusterPolicyCommand, } from "./commands/GetClusterPolicyCommand";
 import { GetCompatibleKafkaVersionsCommand, } from "./commands/GetCompatibleKafkaVersionsCommand";
+import { ListClientVpcConnectionsCommand, } from "./commands/ListClientVpcConnectionsCommand";
 import { ListClusterOperationsCommand, } from "./commands/ListClusterOperationsCommand";
 import { ListClustersCommand, } from "./commands/ListClustersCommand";
 import { ListClustersV2Command, } from "./commands/ListClustersV2Command";
@@ -22,7 +28,10 @@ import { ListKafkaVersionsCommand, } from "./commands/ListKafkaVersionsCommand";
 import { ListNodesCommand } from "./commands/ListNodesCommand";
 import { ListScramSecretsCommand, } from "./commands/ListScramSecretsCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
+import { ListVpcConnectionsCommand, } from "./commands/ListVpcConnectionsCommand";
+import { PutClusterPolicyCommand, } from "./commands/PutClusterPolicyCommand";
 import { RebootBrokerCommand, } from "./commands/RebootBrokerCommand";
+import { RejectClientVpcConnectionCommand, } from "./commands/RejectClientVpcConnectionCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateBrokerCountCommand, } from "./commands/UpdateBrokerCountCommand";
@@ -42,15 +51,21 @@ const commands = {
     CreateClusterCommand,
     CreateClusterV2Command,
     CreateConfigurationCommand,
+    CreateVpcConnectionCommand,
     DeleteClusterCommand,
+    DeleteClusterPolicyCommand,
     DeleteConfigurationCommand,
+    DeleteVpcConnectionCommand,
     DescribeClusterCommand,
     DescribeClusterOperationCommand,
     DescribeClusterV2Command,
     DescribeConfigurationCommand,
     DescribeConfigurationRevisionCommand,
+    DescribeVpcConnectionCommand,
     GetBootstrapBrokersCommand,
+    GetClusterPolicyCommand,
     GetCompatibleKafkaVersionsCommand,
+    ListClientVpcConnectionsCommand,
     ListClusterOperationsCommand,
     ListClustersCommand,
     ListClustersV2Command,
@@ -60,7 +75,10 @@ const commands = {
     ListNodesCommand,
     ListScramSecretsCommand,
     ListTagsForResourceCommand,
+    ListVpcConnectionsCommand,
+    PutClusterPolicyCommand,
     RebootBrokerCommand,
+    RejectClientVpcConnectionCommand,
     TagResourceCommand,
     UntagResourceCommand,
     UpdateBrokerCountCommand,

package/dist-es/commands/CreateVpcConnectionCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_CreateVpcConnectionCommand, se_CreateVpcConnectionCommand } from "../protocols/Aws_restJson1";
+export class CreateVpcConnectionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateVpcConnectionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "KafkaClient";
+        const commandName = "CreateVpcConnectionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateVpcConnectionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateVpcConnectionCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteClusterPolicyCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_DeleteClusterPolicyCommand, se_DeleteClusterPolicyCommand } from "../protocols/Aws_restJson1";
+export class DeleteClusterPolicyCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteClusterPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "KafkaClient";
+        const commandName = "DeleteClusterPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteClusterPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteClusterPolicyCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteVpcConnectionCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_DeleteVpcConnectionCommand, se_DeleteVpcConnectionCommand } from "../protocols/Aws_restJson1";
+export class DeleteVpcConnectionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteVpcConnectionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "KafkaClient";
+        const commandName = "DeleteVpcConnectionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteVpcConnectionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteVpcConnectionCommand(output, context);
+    }
+}

package/dist-es/commands/DescribeVpcConnectionCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_DescribeVpcConnectionCommand, se_DescribeVpcConnectionCommand } from "../protocols/Aws_restJson1";
+export class DescribeVpcConnectionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DescribeVpcConnectionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "KafkaClient";
+        const commandName = "DescribeVpcConnectionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DescribeVpcConnectionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DescribeVpcConnectionCommand(output, context);
+    }
+}

package/dist-es/commands/GetClusterPolicyCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_GetClusterPolicyCommand, se_GetClusterPolicyCommand } from "../protocols/Aws_restJson1";
+export class GetClusterPolicyCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetClusterPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "KafkaClient";
+        const commandName = "GetClusterPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetClusterPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetClusterPolicyCommand(output, context);
+    }
+}

package/dist-es/commands/ListClientVpcConnectionsCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_ListClientVpcConnectionsCommand, se_ListClientVpcConnectionsCommand } from "../protocols/Aws_restJson1";
+export class ListClientVpcConnectionsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListClientVpcConnectionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "KafkaClient";
+        const commandName = "ListClientVpcConnectionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListClientVpcConnectionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListClientVpcConnectionsCommand(output, context);
+    }
+}

package/dist-es/commands/ListVpcConnectionsCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_ListVpcConnectionsCommand, se_ListVpcConnectionsCommand } from "../protocols/Aws_restJson1";
+export class ListVpcConnectionsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListVpcConnectionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "KafkaClient";
+        const commandName = "ListVpcConnectionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListVpcConnectionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListVpcConnectionsCommand(output, context);
+    }
+}

package/dist-es/commands/PutClusterPolicyCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_PutClusterPolicyCommand, se_PutClusterPolicyCommand } from "../protocols/Aws_restJson1";
+export class PutClusterPolicyCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PutClusterPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "KafkaClient";
+        const commandName = "PutClusterPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_PutClusterPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_PutClusterPolicyCommand(output, context);
+    }
+}

package/dist-es/commands/RejectClientVpcConnectionCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_RejectClientVpcConnectionCommand, se_RejectClientVpcConnectionCommand } from "../protocols/Aws_restJson1";
+export class RejectClientVpcConnectionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, RejectClientVpcConnectionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "KafkaClient";
+        const commandName = "RejectClientVpcConnectionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_RejectClientVpcConnectionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_RejectClientVpcConnectionCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -3,15 +3,21 @@ export * from "./BatchDisassociateScramSecretCommand";
 export * from "./CreateClusterCommand";
 export * from "./CreateClusterV2Command";
 export * from "./CreateConfigurationCommand";
+export * from "./CreateVpcConnectionCommand";
 export * from "./DeleteClusterCommand";
+export * from "./DeleteClusterPolicyCommand";
 export * from "./DeleteConfigurationCommand";
+export * from "./DeleteVpcConnectionCommand";
 export * from "./DescribeClusterCommand";
 export * from "./DescribeClusterOperationCommand";
 export * from "./DescribeClusterV2Command";
 export * from "./DescribeConfigurationCommand";
 export * from "./DescribeConfigurationRevisionCommand";
+export * from "./DescribeVpcConnectionCommand";
 export * from "./GetBootstrapBrokersCommand";
+export * from "./GetClusterPolicyCommand";
 export * from "./GetCompatibleKafkaVersionsCommand";
+export * from "./ListClientVpcConnectionsCommand";
 export * from "./ListClusterOperationsCommand";
 export * from "./ListClustersCommand";
 export * from "./ListClustersV2Command";
@@ -21,7 +27,10 @@ export * from "./ListKafkaVersionsCommand";
 export * from "./ListNodesCommand";
 export * from "./ListScramSecretsCommand";
 export * from "./ListTagsForResourceCommand";
+export * from "./ListVpcConnectionsCommand";
+export * from "./PutClusterPolicyCommand";
 export * from "./RebootBrokerCommand";
+export * from "./RejectClientVpcConnectionCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";
 export * from "./UpdateBrokerCountCommand";

package/dist-es/endpoint/ruleset.js

@@ -1,4 +1,4 @@
-const s = "fn", t = "argv", u = "ref";
-const a = true, b = false, c = "String", d = "PartitionResult", e = "tree", f = "error", g = "endpoint", h = "getAttr", i = { "required": true, "default": false, "type": "Boolean" }, j = { [u]: "Endpoint" }, k = { [s]: "booleanEquals", [t]: [{ [u]: "UseFIPS" }, true] }, l = { [s]: "booleanEquals", [t]: [{ [u]: "UseDualStack" }, true] }, m = {}, n = { [s]: "booleanEquals", [t]: [true, { [s]: h, [t]: [{ [u]: d }, "supportsFIPS"] }] }, o = { [u]: d }, p = { [s]: "booleanEquals", [t]: [true, { [s]: h, [t]: [o, "supportsDualStack"] }] }, q = [k], r = [l];
-const _data = { version: "1.0", parameters: { Region: { required: a, type: c }, UseDualStack: i, UseFIPS: i, Endpoint: { required: b, type: c } }, rules: [{ conditions: [{ [s]: "aws.partition", [t]: [{ [u]: "Region" }], assign: d }], type: e, rules: [{ conditions: [{ [s]: "isSet", [t]: [j] }], type: e, rules: [{ conditions: q, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: f }, { type: e, rules: [{ conditions: r, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: f }, { endpoint: { url: j, properties: m, headers: m }, type: g }] }] }, { conditions: [k, l], type: e, rules: [{ conditions: [n, p], type: e, rules: [{ type: e, rules: [{ endpoint: { url: "https://kafka-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: g }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: f }] }, { conditions: q, type: e, rules: [{ conditions: [n], type: e, rules: [{ type: e, rules: [{ conditions: [{ [s]: "stringEquals", [t]: ["aws-us-gov", { [s]: h, [t]: [o, "name"] }] }], endpoint: { url: "https://kafka.{Region}.amazonaws.com", properties: m, headers: m }, type: g }, { endpoint: { url: "https://kafka-fips.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: g }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: f }] }, { conditions: r, type: e, rules: [{ conditions: [p], type: e, rules: [{ type: e, rules: [{ endpoint: { url: "https://kafka.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: g }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: f }] }, { type: e, rules: [{ endpoint: { url: "https://kafka.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: g }] }] }] };
+const s = "required", t = "fn", u = "argv", v = "ref";
+const a = "isSet", b = "tree", c = "error", d = "endpoint", e = "PartitionResult", f = "getAttr", g = { [s]: false, "type": "String" }, h = { [s]: true, "default": false, "type": "Boolean" }, i = { [v]: "Endpoint" }, j = { [t]: "booleanEquals", [u]: [{ [v]: "UseFIPS" }, true] }, k = { [t]: "booleanEquals", [u]: [{ [v]: "UseDualStack" }, true] }, l = {}, m = { [t]: "booleanEquals", [u]: [true, { [t]: f, [u]: [{ [v]: e }, "supportsFIPS"] }] }, n = { [v]: e }, o = { [t]: "booleanEquals", [u]: [true, { [t]: f, [u]: [n, "supportsDualStack"] }] }, p = [j], q = [k], r = [{ [v]: "Region" }];
+const _data = { version: "1.0", parameters: { Region: g, UseDualStack: h, UseFIPS: h, Endpoint: g }, rules: [{ conditions: [{ [t]: a, [u]: [i] }], type: b, rules: [{ conditions: p, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: q, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: i, properties: l, headers: l }, type: d }] }] }, { type: b, rules: [{ conditions: [{ [t]: a, [u]: r }], type: b, rules: [{ conditions: [{ [t]: "aws.partition", [u]: r, assign: e }], type: b, rules: [{ conditions: [j, k], type: b, rules: [{ conditions: [m, o], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://kafka-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: d }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: p, type: b, rules: [{ conditions: [m], type: b, rules: [{ type: b, rules: [{ conditions: [{ [t]: "stringEquals", [u]: ["aws-us-gov", { [t]: f, [u]: [n, "name"] }] }], endpoint: { url: "https://kafka.{Region}.amazonaws.com", properties: l, headers: l }, type: d }, { endpoint: { url: "https://kafka-fips.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: q, type: b, rules: [{ conditions: [o], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://kafka.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: d }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { type: b, rules: [{ endpoint: { url: "https://kafka.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: d }] }] }] }, { error: "Invalid Configuration: Missing Region", type: c }] }] };
 export const ruleSet = _data;

package/dist-es/models/models_0.js

@@ -1,4 +1,14 @@
 import { KafkaServiceException as __BaseException } from "./KafkaServiceException";
+export const VpcConnectionState = {
+    AVAILABLE: "AVAILABLE",
+    CREATING: "CREATING",
+    DEACTIVATING: "DEACTIVATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+    INACTIVE: "INACTIVE",
+    REJECTED: "REJECTED",
+    REJECTING: "REJECTING",
+};
 export const ClusterType = {
     PROVISIONED: "PROVISIONED",
     SERVERLESS: "SERVERLESS",
@@ -31,6 +41,10 @@ export const ClusterState = {
     REBOOTING_BROKER: "REBOOTING_BROKER",
     UPDATING: "UPDATING",
 };
+export const UserIdentityType = {
+    AWSACCOUNT: "AWSACCOUNT",
+    AWSSERVICE: "AWSSERVICE",
+};
 export const ConfigurationState = {
     ACTIVE: "ACTIVE",
     DELETE_FAILED: "DELETE_FAILED",

package/dist-es/pagination/ListClientVpcConnectionsPaginator.js

@@ -0,0 +1,25 @@
+import { ListClientVpcConnectionsCommand, } from "../commands/ListClientVpcConnectionsCommand";
+import { KafkaClient } from "../KafkaClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListClientVpcConnectionsCommand(input), ...args);
+};
+export async function* paginateListClientVpcConnections(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof KafkaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Kafka | KafkaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListVpcConnectionsPaginator.js

@@ -0,0 +1,25 @@
+import { ListVpcConnectionsCommand, } from "../commands/ListVpcConnectionsCommand";
+import { KafkaClient } from "../KafkaClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListVpcConnectionsCommand(input), ...args);
+};
+export async function* paginateListVpcConnections(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof KafkaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Kafka | KafkaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -1,4 +1,5 @@
 export * from "./Interfaces";
+export * from "./ListClientVpcConnectionsPaginator";
 export * from "./ListClusterOperationsPaginator";
 export * from "./ListClustersPaginator";
 export * from "./ListClustersV2Paginator";
@@ -7,3 +8,4 @@ export * from "./ListConfigurationsPaginator";
 export * from "./ListKafkaVersionsPaginator";
 export * from "./ListNodesPaginator";
 export * from "./ListScramSecretsPaginator";
+export * from "./ListVpcConnectionsPaginator";