@aws-sdk/client-kafka 3.34.0 → 3.37.0

package/dist-types/ts3.4/commands/DescribeClusterCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
+import { DescribeClusterRequest, DescribeClusterResponse } from "../models/models_0";
+export interface DescribeClusterCommandInput extends DescribeClusterRequest {
+}
+export interface DescribeClusterCommandOutput extends DescribeClusterResponse, __MetadataBearer {
+}
+
+export declare class DescribeClusterCommand extends $Command<DescribeClusterCommandInput, DescribeClusterCommandOutput, KafkaClientResolvedConfig> {
+    readonly input: DescribeClusterCommandInput;
+    constructor(input: DescribeClusterCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeClusterCommandInput, DescribeClusterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/DescribeClusterOperationCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
 import { DescribeClusterOperationRequest, DescribeClusterOperationResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface DescribeClusterOperationCommandInput extends DescribeClusterOperationRequest {
 }
 export interface DescribeClusterOperationCommandOutput extends DescribeClusterOperationResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a description of the cluster operation specified by the ARN.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KafkaClient, DescribeClusterOperationCommand } from "@aws-sdk/client-kafka"; // ES Modules import
- * // const { KafkaClient, DescribeClusterOperationCommand } = require("@aws-sdk/client-kafka"); // CommonJS import
- * const client = new KafkaClient(config);
- * const command = new DescribeClusterOperationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeClusterOperationCommandInput} for command's `input` shape.
- * @see {@link DescribeClusterOperationCommandOutput} for command's `response` shape.
- * @see {@link KafkaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeClusterOperationCommand extends $Command<DescribeClusterOperationCommandInput, DescribeClusterOperationCommandOutput, KafkaClientResolvedConfig> {
     readonly input: DescribeClusterOperationCommandInput;
     constructor(input: DescribeClusterOperationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeClusterOperationCommandInput, DescribeClusterOperationCommandOutput>;
     private serialize;
     private deserialize;

package/{dist/types → dist-types}/ts3.4/commands/DescribeConfigurationCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
 import { DescribeConfigurationRequest, DescribeConfigurationResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface DescribeConfigurationCommandInput extends DescribeConfigurationRequest {
 }
 export interface DescribeConfigurationCommandOutput extends DescribeConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a description of this MSK configuration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KafkaClient, DescribeConfigurationCommand } from "@aws-sdk/client-kafka"; // ES Modules import
- * // const { KafkaClient, DescribeConfigurationCommand } = require("@aws-sdk/client-kafka"); // CommonJS import
- * const client = new KafkaClient(config);
- * const command = new DescribeConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeConfigurationCommandInput} for command's `input` shape.
- * @see {@link DescribeConfigurationCommandOutput} for command's `response` shape.
- * @see {@link KafkaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeConfigurationCommand extends $Command<DescribeConfigurationCommandInput, DescribeConfigurationCommandOutput, KafkaClientResolvedConfig> {
     readonly input: DescribeConfigurationCommandInput;
     constructor(input: DescribeConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConfigurationCommandInput, DescribeConfigurationCommandOutput>;
     private serialize;
     private deserialize;

package/{dist/types → dist-types}/ts3.4/commands/DescribeConfigurationRevisionCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
 import { DescribeConfigurationRevisionRequest, DescribeConfigurationRevisionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface DescribeConfigurationRevisionCommandInput extends DescribeConfigurationRevisionRequest {
 }
 export interface DescribeConfigurationRevisionCommandOutput extends DescribeConfigurationRevisionResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a description of this revision of the configuration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KafkaClient, DescribeConfigurationRevisionCommand } from "@aws-sdk/client-kafka"; // ES Modules import
- * // const { KafkaClient, DescribeConfigurationRevisionCommand } = require("@aws-sdk/client-kafka"); // CommonJS import
- * const client = new KafkaClient(config);
- * const command = new DescribeConfigurationRevisionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeConfigurationRevisionCommandInput} for command's `input` shape.
- * @see {@link DescribeConfigurationRevisionCommandOutput} for command's `response` shape.
- * @see {@link KafkaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeConfigurationRevisionCommand extends $Command<DescribeConfigurationRevisionCommandInput, DescribeConfigurationRevisionCommandOutput, KafkaClientResolvedConfig> {
     readonly input: DescribeConfigurationRevisionCommandInput;
     constructor(input: DescribeConfigurationRevisionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConfigurationRevisionCommandInput, DescribeConfigurationRevisionCommandOutput>;
     private serialize;
     private deserialize;

package/{dist/types → dist-types}/ts3.4/commands/GetBootstrapBrokersCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
 import { GetBootstrapBrokersRequest, GetBootstrapBrokersResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface GetBootstrapBrokersCommandInput extends GetBootstrapBrokersRequest {
 }
 export interface GetBootstrapBrokersCommandOutput extends GetBootstrapBrokersResponse, __MetadataBearer {
 }
-/**
- * <p>A list of brokers that a client application can use to bootstrap.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KafkaClient, GetBootstrapBrokersCommand } from "@aws-sdk/client-kafka"; // ES Modules import
- * // const { KafkaClient, GetBootstrapBrokersCommand } = require("@aws-sdk/client-kafka"); // CommonJS import
- * const client = new KafkaClient(config);
- * const command = new GetBootstrapBrokersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetBootstrapBrokersCommandInput} for command's `input` shape.
- * @see {@link GetBootstrapBrokersCommandOutput} for command's `response` shape.
- * @see {@link KafkaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetBootstrapBrokersCommand extends $Command<GetBootstrapBrokersCommandInput, GetBootstrapBrokersCommandOutput, KafkaClientResolvedConfig> {
     readonly input: GetBootstrapBrokersCommandInput;
     constructor(input: GetBootstrapBrokersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBootstrapBrokersCommandInput, GetBootstrapBrokersCommandOutput>;
     private serialize;
     private deserialize;

package/{dist/types → dist-types}/ts3.4/commands/GetCompatibleKafkaVersionsCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
 import { GetCompatibleKafkaVersionsRequest, GetCompatibleKafkaVersionsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface GetCompatibleKafkaVersionsCommandInput extends GetCompatibleKafkaVersionsRequest {
 }
 export interface GetCompatibleKafkaVersionsCommandOutput extends GetCompatibleKafkaVersionsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the Apache Kafka versions to which you can update the MSK cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KafkaClient, GetCompatibleKafkaVersionsCommand } from "@aws-sdk/client-kafka"; // ES Modules import
- * // const { KafkaClient, GetCompatibleKafkaVersionsCommand } = require("@aws-sdk/client-kafka"); // CommonJS import
- * const client = new KafkaClient(config);
- * const command = new GetCompatibleKafkaVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetCompatibleKafkaVersionsCommandInput} for command's `input` shape.
- * @see {@link GetCompatibleKafkaVersionsCommandOutput} for command's `response` shape.
- * @see {@link KafkaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetCompatibleKafkaVersionsCommand extends $Command<GetCompatibleKafkaVersionsCommandInput, GetCompatibleKafkaVersionsCommandOutput, KafkaClientResolvedConfig> {
     readonly input: GetCompatibleKafkaVersionsCommandInput;
     constructor(input: GetCompatibleKafkaVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCompatibleKafkaVersionsCommandInput, GetCompatibleKafkaVersionsCommandOutput>;
     private serialize;
     private deserialize;

package/{dist/types → dist-types}/ts3.4/commands/ListClusterOperationsCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
 import { ListClusterOperationsRequest, ListClusterOperationsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface ListClusterOperationsCommandInput extends ListClusterOperationsRequest {
 }
 export interface ListClusterOperationsCommandOutput extends ListClusterOperationsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of all the operations that have been performed on the specified MSK cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KafkaClient, ListClusterOperationsCommand } from "@aws-sdk/client-kafka"; // ES Modules import
- * // const { KafkaClient, ListClusterOperationsCommand } = require("@aws-sdk/client-kafka"); // CommonJS import
- * const client = new KafkaClient(config);
- * const command = new ListClusterOperationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListClusterOperationsCommandInput} for command's `input` shape.
- * @see {@link ListClusterOperationsCommandOutput} for command's `response` shape.
- * @see {@link KafkaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListClusterOperationsCommand extends $Command<ListClusterOperationsCommandInput, ListClusterOperationsCommandOutput, KafkaClientResolvedConfig> {
     readonly input: ListClusterOperationsCommandInput;
     constructor(input: ListClusterOperationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListClusterOperationsCommandInput, ListClusterOperationsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListClustersCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
+import { ListClustersRequest, ListClustersResponse } from "../models/models_0";
+export interface ListClustersCommandInput extends ListClustersRequest {
+}
+export interface ListClustersCommandOutput extends ListClustersResponse, __MetadataBearer {
+}
+
+export declare class ListClustersCommand extends $Command<ListClustersCommandInput, ListClustersCommandOutput, KafkaClientResolvedConfig> {
+    readonly input: ListClustersCommandInput;
+    constructor(input: ListClustersCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListClustersCommandInput, ListClustersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/ListConfigurationRevisionsCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
 import { ListConfigurationRevisionsRequest, ListConfigurationRevisionsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface ListConfigurationRevisionsCommandInput extends ListConfigurationRevisionsRequest {
 }
 export interface ListConfigurationRevisionsCommandOutput extends ListConfigurationRevisionsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of all the MSK configurations in this Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KafkaClient, ListConfigurationRevisionsCommand } from "@aws-sdk/client-kafka"; // ES Modules import
- * // const { KafkaClient, ListConfigurationRevisionsCommand } = require("@aws-sdk/client-kafka"); // CommonJS import
- * const client = new KafkaClient(config);
- * const command = new ListConfigurationRevisionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListConfigurationRevisionsCommandInput} for command's `input` shape.
- * @see {@link ListConfigurationRevisionsCommandOutput} for command's `response` shape.
- * @see {@link KafkaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListConfigurationRevisionsCommand extends $Command<ListConfigurationRevisionsCommandInput, ListConfigurationRevisionsCommandOutput, KafkaClientResolvedConfig> {
     readonly input: ListConfigurationRevisionsCommandInput;
     constructor(input: ListConfigurationRevisionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConfigurationRevisionsCommandInput, ListConfigurationRevisionsCommandOutput>;
     private serialize;
     private deserialize;

package/{dist/types → dist-types}/ts3.4/commands/ListConfigurationsCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
 import { ListConfigurationsRequest, ListConfigurationsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface ListConfigurationsCommandInput extends ListConfigurationsRequest {
 }
 export interface ListConfigurationsCommandOutput extends ListConfigurationsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of all the MSK configurations in this Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KafkaClient, ListConfigurationsCommand } from "@aws-sdk/client-kafka"; // ES Modules import
- * // const { KafkaClient, ListConfigurationsCommand } = require("@aws-sdk/client-kafka"); // CommonJS import
- * const client = new KafkaClient(config);
- * const command = new ListConfigurationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListConfigurationsCommandInput} for command's `input` shape.
- * @see {@link ListConfigurationsCommandOutput} for command's `response` shape.
- * @see {@link KafkaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListConfigurationsCommand extends $Command<ListConfigurationsCommandInput, ListConfigurationsCommandOutput, KafkaClientResolvedConfig> {
     readonly input: ListConfigurationsCommandInput;
     constructor(input: ListConfigurationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConfigurationsCommandInput, ListConfigurationsCommandOutput>;
     private serialize;
     private deserialize;

package/{dist/types → dist-types}/ts3.4/commands/ListKafkaVersionsCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
 import { ListKafkaVersionsRequest, ListKafkaVersionsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface ListKafkaVersionsCommandInput extends ListKafkaVersionsRequest {
 }
 export interface ListKafkaVersionsCommandOutput extends ListKafkaVersionsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of Kafka versions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KafkaClient, ListKafkaVersionsCommand } from "@aws-sdk/client-kafka"; // ES Modules import
- * // const { KafkaClient, ListKafkaVersionsCommand } = require("@aws-sdk/client-kafka"); // CommonJS import
- * const client = new KafkaClient(config);
- * const command = new ListKafkaVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListKafkaVersionsCommandInput} for command's `input` shape.
- * @see {@link ListKafkaVersionsCommandOutput} for command's `response` shape.
- * @see {@link KafkaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListKafkaVersionsCommand extends $Command<ListKafkaVersionsCommandInput, ListKafkaVersionsCommandOutput, KafkaClientResolvedConfig> {
     readonly input: ListKafkaVersionsCommandInput;
     constructor(input: ListKafkaVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListKafkaVersionsCommandInput, ListKafkaVersionsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListNodesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
+import { ListNodesRequest, ListNodesResponse } from "../models/models_0";
+export interface ListNodesCommandInput extends ListNodesRequest {
+}
+export interface ListNodesCommandOutput extends ListNodesResponse, __MetadataBearer {
+}
+
+export declare class ListNodesCommand extends $Command<ListNodesCommandInput, ListNodesCommandOutput, KafkaClientResolvedConfig> {
+    readonly input: ListNodesCommandInput;
+    constructor(input: ListNodesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListNodesCommandInput, ListNodesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListScramSecretsCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
+import { ListScramSecretsRequest, ListScramSecretsResponse } from "../models/models_0";
+export interface ListScramSecretsCommandInput extends ListScramSecretsRequest {
+}
+export interface ListScramSecretsCommandOutput extends ListScramSecretsResponse, __MetadataBearer {
+}
+
+export declare class ListScramSecretsCommand extends $Command<ListScramSecretsCommandInput, ListScramSecretsCommandOutput, KafkaClientResolvedConfig> {
+    readonly input: ListScramSecretsCommandInput;
+    constructor(input: ListScramSecretsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListScramSecretsCommandInput, ListScramSecretsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/ListTagsForResourceCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
 import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of the tags associated with the specified resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KafkaClient, ListTagsForResourceCommand } from "@aws-sdk/client-kafka"; // ES Modules import
- * // const { KafkaClient, ListTagsForResourceCommand } = require("@aws-sdk/client-kafka"); // CommonJS import
- * const client = new KafkaClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link KafkaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, KafkaClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

package/{dist/types → dist-types}/ts3.4/commands/RebootBrokerCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
 import { RebootBrokerRequest, RebootBrokerResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface RebootBrokerCommandInput extends RebootBrokerRequest {
 }
 export interface RebootBrokerCommandOutput extends RebootBrokerResponse, __MetadataBearer {
 }
-/**
- * Reboots brokers.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KafkaClient, RebootBrokerCommand } from "@aws-sdk/client-kafka"; // ES Modules import
- * // const { KafkaClient, RebootBrokerCommand } = require("@aws-sdk/client-kafka"); // CommonJS import
- * const client = new KafkaClient(config);
- * const command = new RebootBrokerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RebootBrokerCommandInput} for command's `input` shape.
- * @see {@link RebootBrokerCommandOutput} for command's `response` shape.
- * @see {@link KafkaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RebootBrokerCommand extends $Command<RebootBrokerCommandInput, RebootBrokerCommandOutput, KafkaClientResolvedConfig> {
     readonly input: RebootBrokerCommandInput;
     constructor(input: RebootBrokerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RebootBrokerCommandInput, RebootBrokerCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/TagResourceCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
+import { TagResourceRequest } from "../models/models_0";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends __MetadataBearer {
+}
+
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, KafkaClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/UntagResourceCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
+import { UntagResourceRequest } from "../models/models_0";
+export interface UntagResourceCommandInput extends UntagResourceRequest {
+}
+export interface UntagResourceCommandOutput extends __MetadataBearer {
+}
+
+export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, KafkaClientResolvedConfig> {
+    readonly input: UntagResourceCommandInput;
+    constructor(input: UntagResourceCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/UpdateBrokerCountCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
 import { UpdateBrokerCountRequest, UpdateBrokerCountResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface UpdateBrokerCountCommandInput extends UpdateBrokerCountRequest {
 }
 export interface UpdateBrokerCountCommandOutput extends UpdateBrokerCountResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the number of broker nodes in the cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KafkaClient, UpdateBrokerCountCommand } from "@aws-sdk/client-kafka"; // ES Modules import
- * // const { KafkaClient, UpdateBrokerCountCommand } = require("@aws-sdk/client-kafka"); // CommonJS import
- * const client = new KafkaClient(config);
- * const command = new UpdateBrokerCountCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateBrokerCountCommandInput} for command's `input` shape.
- * @see {@link UpdateBrokerCountCommandOutput} for command's `response` shape.
- * @see {@link KafkaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateBrokerCountCommand extends $Command<UpdateBrokerCountCommandInput, UpdateBrokerCountCommandOutput, KafkaClientResolvedConfig> {
     readonly input: UpdateBrokerCountCommandInput;
     constructor(input: UpdateBrokerCountCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateBrokerCountCommandInput, UpdateBrokerCountCommandOutput>;
     private serialize;
     private deserialize;

package/{dist/types → dist-types}/ts3.4/commands/UpdateBrokerStorageCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { KafkaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KafkaClient";
 import { UpdateBrokerStorageRequest, UpdateBrokerStorageResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface UpdateBrokerStorageCommandInput extends UpdateBrokerStorageRequest {
 }
 export interface UpdateBrokerStorageCommandOutput extends UpdateBrokerStorageResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the EBS storage associated with MSK brokers.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KafkaClient, UpdateBrokerStorageCommand } from "@aws-sdk/client-kafka"; // ES Modules import
- * // const { KafkaClient, UpdateBrokerStorageCommand } = require("@aws-sdk/client-kafka"); // CommonJS import
- * const client = new KafkaClient(config);
- * const command = new UpdateBrokerStorageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateBrokerStorageCommandInput} for command's `input` shape.
- * @see {@link UpdateBrokerStorageCommandOutput} for command's `response` shape.
- * @see {@link KafkaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateBrokerStorageCommand extends $Command<UpdateBrokerStorageCommandInput, UpdateBrokerStorageCommandOutput, KafkaClientResolvedConfig> {
     readonly input: UpdateBrokerStorageCommandInput;
     constructor(input: UpdateBrokerStorageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KafkaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateBrokerStorageCommandInput, UpdateBrokerStorageCommandOutput>;
     private serialize;
     private deserialize;