@aws-sdk/client-kafka 3.50.0 → 3.51.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,1589 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface ProvisionedThroughput {
+    
+    Enabled?: boolean;
+    
+    VolumeThroughput?: number;
+}
+export declare namespace ProvisionedThroughput {
+    
+    const filterSensitiveLog: (obj: ProvisionedThroughput) => any;
+}
+
+export interface BrokerEBSVolumeInfo {
+    
+    KafkaBrokerNodeId: string | undefined;
+    
+    ProvisionedThroughput?: ProvisionedThroughput;
+    
+    VolumeSizeGB?: number;
+}
+export declare namespace BrokerEBSVolumeInfo {
+    
+    const filterSensitiveLog: (obj: BrokerEBSVolumeInfo) => any;
+}
+export declare enum ClusterType {
+    PROVISIONED = "PROVISIONED",
+    SERVERLESS = "SERVERLESS"
+}
+export declare enum BrokerAZDistribution {
+    DEFAULT = "DEFAULT"
+}
+
+export interface PublicAccess {
+    
+    Type?: string;
+}
+export declare namespace PublicAccess {
+    
+    const filterSensitiveLog: (obj: PublicAccess) => any;
+}
+
+export interface ConnectivityInfo {
+    
+    PublicAccess?: PublicAccess;
+}
+export declare namespace ConnectivityInfo {
+    
+    const filterSensitiveLog: (obj: ConnectivityInfo) => any;
+}
+
+export interface EBSStorageInfo {
+    
+    ProvisionedThroughput?: ProvisionedThroughput;
+    
+    VolumeSize?: number;
+}
+export declare namespace EBSStorageInfo {
+    
+    const filterSensitiveLog: (obj: EBSStorageInfo) => any;
+}
+
+export interface StorageInfo {
+    
+    EbsStorageInfo?: EBSStorageInfo;
+}
+export declare namespace StorageInfo {
+    
+    const filterSensitiveLog: (obj: StorageInfo) => any;
+}
+
+export interface BrokerNodeGroupInfo {
+    
+    BrokerAZDistribution?: BrokerAZDistribution | string;
+    
+    ClientSubnets: string[] | undefined;
+    
+    InstanceType: string | undefined;
+    
+    SecurityGroups?: string[];
+    
+    StorageInfo?: StorageInfo;
+    
+    ConnectivityInfo?: ConnectivityInfo;
+}
+export declare namespace BrokerNodeGroupInfo {
+    
+    const filterSensitiveLog: (obj: BrokerNodeGroupInfo) => any;
+}
+
+export interface Iam {
+    
+    Enabled?: boolean;
+}
+export declare namespace Iam {
+    
+    const filterSensitiveLog: (obj: Iam) => any;
+}
+
+export interface Scram {
+    
+    Enabled?: boolean;
+}
+export declare namespace Scram {
+    
+    const filterSensitiveLog: (obj: Scram) => any;
+}
+
+export interface Sasl {
+    
+    Scram?: Scram;
+    
+    Iam?: Iam;
+}
+export declare namespace Sasl {
+    
+    const filterSensitiveLog: (obj: Sasl) => any;
+}
+
+export interface Tls {
+    
+    CertificateAuthorityArnList?: string[];
+    
+    Enabled?: boolean;
+}
+export declare namespace Tls {
+    
+    const filterSensitiveLog: (obj: Tls) => any;
+}
+export interface Unauthenticated {
+    
+    Enabled?: boolean;
+}
+export declare namespace Unauthenticated {
+    
+    const filterSensitiveLog: (obj: Unauthenticated) => any;
+}
+
+export interface ClientAuthentication {
+    
+    Sasl?: Sasl;
+    
+    Tls?: Tls;
+    
+    Unauthenticated?: Unauthenticated;
+}
+export declare namespace ClientAuthentication {
+    
+    const filterSensitiveLog: (obj: ClientAuthentication) => any;
+}
+
+export interface BrokerSoftwareInfo {
+    
+    ConfigurationArn?: string;
+    
+    ConfigurationRevision?: number;
+    
+    KafkaVersion?: string;
+}
+export declare namespace BrokerSoftwareInfo {
+    
+    const filterSensitiveLog: (obj: BrokerSoftwareInfo) => any;
+}
+
+export interface EncryptionAtRest {
+    
+    DataVolumeKMSKeyId: string | undefined;
+}
+export declare namespace EncryptionAtRest {
+    
+    const filterSensitiveLog: (obj: EncryptionAtRest) => any;
+}
+export declare enum ClientBroker {
+    PLAINTEXT = "PLAINTEXT",
+    TLS = "TLS",
+    TLS_PLAINTEXT = "TLS_PLAINTEXT"
+}
+
+export interface EncryptionInTransit {
+    
+    ClientBroker?: ClientBroker | string;
+    
+    InCluster?: boolean;
+}
+export declare namespace EncryptionInTransit {
+    
+    const filterSensitiveLog: (obj: EncryptionInTransit) => any;
+}
+
+export interface EncryptionInfo {
+    
+    EncryptionAtRest?: EncryptionAtRest;
+    
+    EncryptionInTransit?: EncryptionInTransit;
+}
+export declare namespace EncryptionInfo {
+    
+    const filterSensitiveLog: (obj: EncryptionInfo) => any;
+}
+export declare enum EnhancedMonitoring {
+    DEFAULT = "DEFAULT",
+    PER_BROKER = "PER_BROKER",
+    PER_TOPIC_PER_BROKER = "PER_TOPIC_PER_BROKER",
+    PER_TOPIC_PER_PARTITION = "PER_TOPIC_PER_PARTITION"
+}
+export interface CloudWatchLogs {
+    Enabled: boolean | undefined;
+    LogGroup?: string;
+}
+export declare namespace CloudWatchLogs {
+    
+    const filterSensitiveLog: (obj: CloudWatchLogs) => any;
+}
+export interface Firehose {
+    DeliveryStream?: string;
+    Enabled: boolean | undefined;
+}
+export declare namespace Firehose {
+    
+    const filterSensitiveLog: (obj: Firehose) => any;
+}
+export interface S3 {
+    Bucket?: string;
+    Enabled: boolean | undefined;
+    Prefix?: string;
+}
+export declare namespace S3 {
+    
+    const filterSensitiveLog: (obj: S3) => any;
+}
+export interface BrokerLogs {
+    CloudWatchLogs?: CloudWatchLogs;
+    Firehose?: Firehose;
+    S3?: S3;
+}
+export declare namespace BrokerLogs {
+    
+    const filterSensitiveLog: (obj: BrokerLogs) => any;
+}
+export interface LoggingInfo {
+    BrokerLogs: BrokerLogs | undefined;
+}
+export declare namespace LoggingInfo {
+    
+    const filterSensitiveLog: (obj: LoggingInfo) => any;
+}
+
+export interface JmxExporterInfo {
+    
+    EnabledInBroker: boolean | undefined;
+}
+export declare namespace JmxExporterInfo {
+    
+    const filterSensitiveLog: (obj: JmxExporterInfo) => any;
+}
+
+export interface NodeExporterInfo {
+    
+    EnabledInBroker: boolean | undefined;
+}
+export declare namespace NodeExporterInfo {
+    
+    const filterSensitiveLog: (obj: NodeExporterInfo) => any;
+}
+
+export interface PrometheusInfo {
+    
+    JmxExporter?: JmxExporterInfo;
+    
+    NodeExporter?: NodeExporterInfo;
+}
+export declare namespace PrometheusInfo {
+    
+    const filterSensitiveLog: (obj: PrometheusInfo) => any;
+}
+
+export interface OpenMonitoringInfo {
+    
+    Prometheus: PrometheusInfo | undefined;
+}
+export declare namespace OpenMonitoringInfo {
+    
+    const filterSensitiveLog: (obj: OpenMonitoringInfo) => any;
+}
+
+export interface Provisioned {
+    
+    BrokerNodeGroupInfo: BrokerNodeGroupInfo | undefined;
+    
+    CurrentBrokerSoftwareInfo?: BrokerSoftwareInfo;
+    
+    ClientAuthentication?: ClientAuthentication;
+    
+    EncryptionInfo?: EncryptionInfo;
+    
+    EnhancedMonitoring?: EnhancedMonitoring | string;
+    
+    OpenMonitoring?: OpenMonitoringInfo;
+    
+    LoggingInfo?: LoggingInfo;
+    
+    NumberOfBrokerNodes: number | undefined;
+    
+    ZookeeperConnectString?: string;
+    
+    ZookeeperConnectStringTls?: string;
+}
+export declare namespace Provisioned {
+    
+    const filterSensitiveLog: (obj: Provisioned) => any;
+}
+
+export interface ServerlessSasl {
+    
+    Iam?: Iam;
+}
+export declare namespace ServerlessSasl {
+    
+    const filterSensitiveLog: (obj: ServerlessSasl) => any;
+}
+
+export interface ServerlessClientAuthentication {
+    
+    Sasl?: ServerlessSasl;
+}
+export declare namespace ServerlessClientAuthentication {
+    
+    const filterSensitiveLog: (obj: ServerlessClientAuthentication) => any;
+}
+
+export interface VpcConfig {
+    
+    SubnetIds: string[] | undefined;
+    
+    SecurityGroupIds?: string[];
+}
+export declare namespace VpcConfig {
+    
+    const filterSensitiveLog: (obj: VpcConfig) => any;
+}
+
+export interface Serverless {
+    
+    VpcConfigs: VpcConfig[] | undefined;
+    
+    ClientAuthentication?: ServerlessClientAuthentication;
+}
+export declare namespace Serverless {
+    
+    const filterSensitiveLog: (obj: Serverless) => any;
+}
+export declare enum ClusterState {
+    ACTIVE = "ACTIVE",
+    CREATING = "CREATING",
+    DELETING = "DELETING",
+    FAILED = "FAILED",
+    HEALING = "HEALING",
+    MAINTENANCE = "MAINTENANCE",
+    REBOOTING_BROKER = "REBOOTING_BROKER",
+    UPDATING = "UPDATING"
+}
+export interface StateInfo {
+    Code?: string;
+    Message?: string;
+}
+export declare namespace StateInfo {
+    
+    const filterSensitiveLog: (obj: StateInfo) => any;
+}
+
+export interface Cluster {
+    
+    ActiveOperationArn?: string;
+    
+    ClusterType?: ClusterType | string;
+    
+    ClusterArn?: string;
+    
+    ClusterName?: string;
+    
+    CreationTime?: Date;
+    
+    CurrentVersion?: string;
+    
+    State?: ClusterState | string;
+    
+    StateInfo?: StateInfo;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Provisioned?: Provisioned;
+    
+    Serverless?: Serverless;
+}
+export declare namespace Cluster {
+    
+    const filterSensitiveLog: (obj: Cluster) => any;
+}
+
+export interface JmxExporter {
+    
+    EnabledInBroker: boolean | undefined;
+}
+export declare namespace JmxExporter {
+    
+    const filterSensitiveLog: (obj: JmxExporter) => any;
+}
+
+export interface NodeExporter {
+    
+    EnabledInBroker: boolean | undefined;
+}
+export declare namespace NodeExporter {
+    
+    const filterSensitiveLog: (obj: NodeExporter) => any;
+}
+
+export interface Prometheus {
+    
+    JmxExporter?: JmxExporter;
+    
+    NodeExporter?: NodeExporter;
+}
+export declare namespace Prometheus {
+    
+    const filterSensitiveLog: (obj: Prometheus) => any;
+}
+
+export interface OpenMonitoring {
+    
+    Prometheus: Prometheus | undefined;
+}
+export declare namespace OpenMonitoring {
+    
+    const filterSensitiveLog: (obj: OpenMonitoring) => any;
+}
+
+export interface ClusterInfo {
+    
+    ActiveOperationArn?: string;
+    
+    BrokerNodeGroupInfo?: BrokerNodeGroupInfo;
+    
+    ClientAuthentication?: ClientAuthentication;
+    
+    ClusterArn?: string;
+    
+    ClusterName?: string;
+    
+    CreationTime?: Date;
+    
+    CurrentBrokerSoftwareInfo?: BrokerSoftwareInfo;
+    
+    CurrentVersion?: string;
+    
+    EncryptionInfo?: EncryptionInfo;
+    
+    EnhancedMonitoring?: EnhancedMonitoring | string;
+    
+    OpenMonitoring?: OpenMonitoring;
+    LoggingInfo?: LoggingInfo;
+    
+    NumberOfBrokerNodes?: number;
+    
+    State?: ClusterState | string;
+    StateInfo?: StateInfo;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    ZookeeperConnectString?: string;
+    
+    ZookeeperConnectStringTls?: string;
+}
+export declare namespace ClusterInfo {
+    
+    const filterSensitiveLog: (obj: ClusterInfo) => any;
+}
+
+export interface ErrorInfo {
+    
+    ErrorCode?: string;
+    
+    ErrorString?: string;
+}
+export declare namespace ErrorInfo {
+    
+    const filterSensitiveLog: (obj: ErrorInfo) => any;
+}
+
+export interface ClusterOperationStepInfo {
+    
+    StepStatus?: string;
+}
+export declare namespace ClusterOperationStepInfo {
+    
+    const filterSensitiveLog: (obj: ClusterOperationStepInfo) => any;
+}
+
+export interface ClusterOperationStep {
+    
+    StepInfo?: ClusterOperationStepInfo;
+    
+    StepName?: string;
+}
+export declare namespace ClusterOperationStep {
+    
+    const filterSensitiveLog: (obj: ClusterOperationStep) => any;
+}
+
+export interface ConfigurationInfo {
+    
+    Arn: string | undefined;
+    
+    Revision: number | undefined;
+}
+export declare namespace ConfigurationInfo {
+    
+    const filterSensitiveLog: (obj: ConfigurationInfo) => any;
+}
+
+export interface MutableClusterInfo {
+    
+    BrokerEBSVolumeInfo?: BrokerEBSVolumeInfo[];
+    
+    ConfigurationInfo?: ConfigurationInfo;
+    
+    NumberOfBrokerNodes?: number;
+    
+    EnhancedMonitoring?: EnhancedMonitoring | string;
+    
+    OpenMonitoring?: OpenMonitoring;
+    
+    KafkaVersion?: string;
+    
+    LoggingInfo?: LoggingInfo;
+    
+    InstanceType?: string;
+    
+    ClientAuthentication?: ClientAuthentication;
+    
+    EncryptionInfo?: EncryptionInfo;
+    
+    ConnectivityInfo?: ConnectivityInfo;
+}
+export declare namespace MutableClusterInfo {
+    
+    const filterSensitiveLog: (obj: MutableClusterInfo) => any;
+}
+
+export interface ClusterOperationInfo {
+    
+    ClientRequestId?: string;
+    
+    ClusterArn?: string;
+    
+    CreationTime?: Date;
+    
+    EndTime?: Date;
+    
+    ErrorInfo?: ErrorInfo;
+    
+    OperationArn?: string;
+    
+    OperationState?: string;
+    
+    OperationSteps?: ClusterOperationStep[];
+    
+    OperationType?: string;
+    
+    SourceClusterInfo?: MutableClusterInfo;
+    
+    TargetClusterInfo?: MutableClusterInfo;
+}
+export declare namespace ClusterOperationInfo {
+    
+    const filterSensitiveLog: (obj: ClusterOperationInfo) => any;
+}
+
+export interface CompatibleKafkaVersion {
+    
+    SourceVersion?: string;
+    
+    TargetVersions?: string[];
+}
+export declare namespace CompatibleKafkaVersion {
+    
+    const filterSensitiveLog: (obj: CompatibleKafkaVersion) => any;
+}
+
+export interface ConfigurationRevision {
+    
+    CreationTime: Date | undefined;
+    
+    Description?: string;
+    
+    Revision: number | undefined;
+}
+export declare namespace ConfigurationRevision {
+    
+    const filterSensitiveLog: (obj: ConfigurationRevision) => any;
+}
+export declare enum ConfigurationState {
+    ACTIVE = "ACTIVE",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETING = "DELETING"
+}
+
+export interface Configuration {
+    
+    Arn: string | undefined;
+    
+    CreationTime: Date | undefined;
+    
+    Description: string | undefined;
+    
+    KafkaVersions: string[] | undefined;
+    
+    LatestRevision: ConfigurationRevision | undefined;
+    
+    Name: string | undefined;
+    
+    State: ConfigurationState | string | undefined;
+}
+export declare namespace Configuration {
+    
+    const filterSensitiveLog: (obj: Configuration) => any;
+}
+export declare enum KafkaVersionStatus {
+    ACTIVE = "ACTIVE",
+    DEPRECATED = "DEPRECATED"
+}
+export interface KafkaVersion {
+    Version?: string;
+    Status?: KafkaVersionStatus | string;
+}
+export declare namespace KafkaVersion {
+    
+    const filterSensitiveLog: (obj: KafkaVersion) => any;
+}
+
+export interface BrokerNodeInfo {
+    
+    AttachedENIId?: string;
+    
+    BrokerId?: number;
+    
+    ClientSubnet?: string;
+    
+    ClientVpcIpAddress?: string;
+    
+    CurrentBrokerSoftwareInfo?: BrokerSoftwareInfo;
+    
+    Endpoints?: string[];
+}
+export declare namespace BrokerNodeInfo {
+    
+    const filterSensitiveLog: (obj: BrokerNodeInfo) => any;
+}
+export declare enum NodeType {
+    BROKER = "BROKER"
+}
+
+export interface ZookeeperNodeInfo {
+    
+    AttachedENIId?: string;
+    
+    ClientVpcIpAddress?: string;
+    
+    Endpoints?: string[];
+    
+    ZookeeperId?: number;
+    
+    ZookeeperVersion?: string;
+}
+export declare namespace ZookeeperNodeInfo {
+    
+    const filterSensitiveLog: (obj: ZookeeperNodeInfo) => any;
+}
+
+export interface NodeInfo {
+    
+    AddedToClusterTime?: string;
+    
+    BrokerNodeInfo?: BrokerNodeInfo;
+    
+    InstanceType?: string;
+    
+    NodeARN?: string;
+    
+    NodeType?: NodeType | string;
+    
+    ZookeeperNodeInfo?: ZookeeperNodeInfo;
+}
+export declare namespace NodeInfo {
+    
+    const filterSensitiveLog: (obj: NodeInfo) => any;
+}
+
+export interface UnprocessedScramSecret {
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+    
+    SecretArn?: string;
+}
+export declare namespace UnprocessedScramSecret {
+    
+    const filterSensitiveLog: (obj: UnprocessedScramSecret) => any;
+}
+
+export interface BadRequestException extends __SmithyException, $MetadataBearer {
+    name: "BadRequestException";
+    $fault: "client";
+    
+    InvalidParameter?: string;
+    
+    Message?: string;
+}
+
+export interface BatchAssociateScramSecretRequest {
+    
+    ClusterArn: string | undefined;
+    
+    SecretArnList: string[] | undefined;
+}
+export declare namespace BatchAssociateScramSecretRequest {
+    
+    const filterSensitiveLog: (obj: BatchAssociateScramSecretRequest) => any;
+}
+export interface BatchAssociateScramSecretResponse {
+    
+    ClusterArn?: string;
+    
+    UnprocessedScramSecrets?: UnprocessedScramSecret[];
+}
+export declare namespace BatchAssociateScramSecretResponse {
+    
+    const filterSensitiveLog: (obj: BatchAssociateScramSecretResponse) => any;
+}
+
+export interface ForbiddenException extends __SmithyException, $MetadataBearer {
+    name: "ForbiddenException";
+    $fault: "client";
+    
+    InvalidParameter?: string;
+    
+    Message?: string;
+}
+
+export interface InternalServerErrorException extends __SmithyException, $MetadataBearer {
+    name: "InternalServerErrorException";
+    $fault: "server";
+    
+    InvalidParameter?: string;
+    
+    Message?: string;
+}
+
+export interface NotFoundException extends __SmithyException, $MetadataBearer {
+    name: "NotFoundException";
+    $fault: "client";
+    
+    InvalidParameter?: string;
+    
+    Message?: string;
+}
+
+export interface ServiceUnavailableException extends __SmithyException, $MetadataBearer {
+    name: "ServiceUnavailableException";
+    $fault: "server";
+    
+    InvalidParameter?: string;
+    
+    Message?: string;
+}
+
+export interface TooManyRequestsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyRequestsException";
+    $fault: "client";
+    
+    InvalidParameter?: string;
+    
+    Message?: string;
+}
+
+export interface UnauthorizedException extends __SmithyException, $MetadataBearer {
+    name: "UnauthorizedException";
+    $fault: "client";
+    
+    InvalidParameter?: string;
+    
+    Message?: string;
+}
+
+export interface BatchDisassociateScramSecretRequest {
+    
+    ClusterArn: string | undefined;
+    
+    SecretArnList: string[] | undefined;
+}
+export declare namespace BatchDisassociateScramSecretRequest {
+    
+    const filterSensitiveLog: (obj: BatchDisassociateScramSecretRequest) => any;
+}
+export interface BatchDisassociateScramSecretResponse {
+    
+    ClusterArn?: string;
+    
+    UnprocessedScramSecrets?: UnprocessedScramSecret[];
+}
+export declare namespace BatchDisassociateScramSecretResponse {
+    
+    const filterSensitiveLog: (obj: BatchDisassociateScramSecretResponse) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    
+    InvalidParameter?: string;
+    
+    Message?: string;
+}
+export interface CreateClusterRequest {
+    
+    BrokerNodeGroupInfo: BrokerNodeGroupInfo | undefined;
+    
+    ClientAuthentication?: ClientAuthentication;
+    
+    ClusterName: string | undefined;
+    
+    ConfigurationInfo?: ConfigurationInfo;
+    
+    EncryptionInfo?: EncryptionInfo;
+    
+    EnhancedMonitoring?: EnhancedMonitoring | string;
+    
+    OpenMonitoring?: OpenMonitoringInfo;
+    
+    KafkaVersion: string | undefined;
+    LoggingInfo?: LoggingInfo;
+    
+    NumberOfBrokerNodes: number | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateClusterRequest {
+    
+    const filterSensitiveLog: (obj: CreateClusterRequest) => any;
+}
+export interface CreateClusterResponse {
+    
+    ClusterArn?: string;
+    
+    ClusterName?: string;
+    
+    State?: ClusterState | string;
+}
+export declare namespace CreateClusterResponse {
+    
+    const filterSensitiveLog: (obj: CreateClusterResponse) => any;
+}
+
+export interface ProvisionedRequest {
+    
+    BrokerNodeGroupInfo: BrokerNodeGroupInfo | undefined;
+    
+    ClientAuthentication?: ClientAuthentication;
+    
+    ConfigurationInfo?: ConfigurationInfo;
+    
+    EncryptionInfo?: EncryptionInfo;
+    
+    EnhancedMonitoring?: EnhancedMonitoring | string;
+    
+    OpenMonitoring?: OpenMonitoringInfo;
+    
+    KafkaVersion: string | undefined;
+    
+    LoggingInfo?: LoggingInfo;
+    
+    NumberOfBrokerNodes: number | undefined;
+}
+export declare namespace ProvisionedRequest {
+    
+    const filterSensitiveLog: (obj: ProvisionedRequest) => any;
+}
+
+export interface ServerlessRequest {
+    
+    VpcConfigs: VpcConfig[] | undefined;
+    
+    ClientAuthentication?: ServerlessClientAuthentication;
+}
+export declare namespace ServerlessRequest {
+    
+    const filterSensitiveLog: (obj: ServerlessRequest) => any;
+}
+export interface CreateClusterV2Request {
+    
+    ClusterName: string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Provisioned?: ProvisionedRequest;
+    
+    Serverless?: ServerlessRequest;
+}
+export declare namespace CreateClusterV2Request {
+    
+    const filterSensitiveLog: (obj: CreateClusterV2Request) => any;
+}
+export interface CreateClusterV2Response {
+    
+    ClusterArn?: string;
+    
+    ClusterName?: string;
+    
+    State?: ClusterState | string;
+    
+    ClusterType?: ClusterType | string;
+}
+export declare namespace CreateClusterV2Response {
+    
+    const filterSensitiveLog: (obj: CreateClusterV2Response) => any;
+}
+export interface CreateConfigurationRequest {
+    
+    Description?: string;
+    
+    KafkaVersions?: string[];
+    
+    Name: string | undefined;
+    
+    ServerProperties: Uint8Array | undefined;
+}
+export declare namespace CreateConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: CreateConfigurationRequest) => any;
+}
+export interface CreateConfigurationResponse {
+    
+    Arn?: string;
+    
+    CreationTime?: Date;
+    
+    LatestRevision?: ConfigurationRevision;
+    
+    Name?: string;
+    
+    State?: ConfigurationState | string;
+}
+export declare namespace CreateConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: CreateConfigurationResponse) => any;
+}
+export interface DeleteClusterRequest {
+    
+    ClusterArn: string | undefined;
+    
+    CurrentVersion?: string;
+}
+export declare namespace DeleteClusterRequest {
+    
+    const filterSensitiveLog: (obj: DeleteClusterRequest) => any;
+}
+export interface DeleteClusterResponse {
+    
+    ClusterArn?: string;
+    
+    State?: ClusterState | string;
+}
+export declare namespace DeleteClusterResponse {
+    
+    const filterSensitiveLog: (obj: DeleteClusterResponse) => any;
+}
+export interface DeleteConfigurationRequest {
+    
+    Arn: string | undefined;
+}
+export declare namespace DeleteConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteConfigurationRequest) => any;
+}
+export interface DeleteConfigurationResponse {
+    
+    Arn?: string;
+    
+    State?: ConfigurationState | string;
+}
+export declare namespace DeleteConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteConfigurationResponse) => any;
+}
+export interface DescribeClusterRequest {
+    
+    ClusterArn: string | undefined;
+}
+export declare namespace DescribeClusterRequest {
+    
+    const filterSensitiveLog: (obj: DescribeClusterRequest) => any;
+}
+export interface DescribeClusterResponse {
+    
+    ClusterInfo?: ClusterInfo;
+}
+export declare namespace DescribeClusterResponse {
+    
+    const filterSensitiveLog: (obj: DescribeClusterResponse) => any;
+}
+export interface DescribeClusterOperationRequest {
+    
+    ClusterOperationArn: string | undefined;
+}
+export declare namespace DescribeClusterOperationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeClusterOperationRequest) => any;
+}
+export interface DescribeClusterOperationResponse {
+    
+    ClusterOperationInfo?: ClusterOperationInfo;
+}
+export declare namespace DescribeClusterOperationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeClusterOperationResponse) => any;
+}
+export interface DescribeClusterV2Request {
+    
+    ClusterArn: string | undefined;
+}
+export declare namespace DescribeClusterV2Request {
+    
+    const filterSensitiveLog: (obj: DescribeClusterV2Request) => any;
+}
+export interface DescribeClusterV2Response {
+    
+    ClusterInfo?: Cluster;
+}
+export declare namespace DescribeClusterV2Response {
+    
+    const filterSensitiveLog: (obj: DescribeClusterV2Response) => any;
+}
+export interface DescribeConfigurationRequest {
+    
+    Arn: string | undefined;
+}
+export declare namespace DescribeConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationRequest) => any;
+}
+export interface DescribeConfigurationResponse {
+    
+    Arn?: string;
+    
+    CreationTime?: Date;
+    
+    Description?: string;
+    
+    KafkaVersions?: string[];
+    
+    LatestRevision?: ConfigurationRevision;
+    
+    Name?: string;
+    
+    State?: ConfigurationState | string;
+}
+export declare namespace DescribeConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationResponse) => any;
+}
+export interface DescribeConfigurationRevisionRequest {
+    
+    Arn: string | undefined;
+    
+    Revision: number | undefined;
+}
+export declare namespace DescribeConfigurationRevisionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationRevisionRequest) => any;
+}
+export interface DescribeConfigurationRevisionResponse {
+    
+    Arn?: string;
+    
+    CreationTime?: Date;
+    
+    Description?: string;
+    
+    Revision?: number;
+    
+    ServerProperties?: Uint8Array;
+}
+export declare namespace DescribeConfigurationRevisionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationRevisionResponse) => any;
+}
+export interface GetBootstrapBrokersRequest {
+    
+    ClusterArn: string | undefined;
+}
+export declare namespace GetBootstrapBrokersRequest {
+    
+    const filterSensitiveLog: (obj: GetBootstrapBrokersRequest) => any;
+}
+export interface GetBootstrapBrokersResponse {
+    
+    BootstrapBrokerString?: string;
+    
+    BootstrapBrokerStringTls?: string;
+    
+    BootstrapBrokerStringSaslScram?: string;
+    
+    BootstrapBrokerStringSaslIam?: string;
+    
+    BootstrapBrokerStringPublicTls?: string;
+    
+    BootstrapBrokerStringPublicSaslScram?: string;
+    
+    BootstrapBrokerStringPublicSaslIam?: string;
+}
+export declare namespace GetBootstrapBrokersResponse {
+    
+    const filterSensitiveLog: (obj: GetBootstrapBrokersResponse) => any;
+}
+export interface GetCompatibleKafkaVersionsRequest {
+    
+    ClusterArn?: string;
+}
+export declare namespace GetCompatibleKafkaVersionsRequest {
+    
+    const filterSensitiveLog: (obj: GetCompatibleKafkaVersionsRequest) => any;
+}
+export interface GetCompatibleKafkaVersionsResponse {
+    
+    CompatibleKafkaVersions?: CompatibleKafkaVersion[];
+}
+export declare namespace GetCompatibleKafkaVersionsResponse {
+    
+    const filterSensitiveLog: (obj: GetCompatibleKafkaVersionsResponse) => any;
+}
+export interface ListClusterOperationsRequest {
+    
+    ClusterArn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListClusterOperationsRequest {
+    
+    const filterSensitiveLog: (obj: ListClusterOperationsRequest) => any;
+}
+export interface ListClusterOperationsResponse {
+    
+    ClusterOperationInfoList?: ClusterOperationInfo[];
+    
+    NextToken?: string;
+}
+export declare namespace ListClusterOperationsResponse {
+    
+    const filterSensitiveLog: (obj: ListClusterOperationsResponse) => any;
+}
+export interface ListClustersRequest {
+    
+    ClusterNameFilter?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListClustersRequest {
+    
+    const filterSensitiveLog: (obj: ListClustersRequest) => any;
+}
+export interface ListClustersResponse {
+    
+    ClusterInfoList?: ClusterInfo[];
+    
+    NextToken?: string;
+}
+export declare namespace ListClustersResponse {
+    
+    const filterSensitiveLog: (obj: ListClustersResponse) => any;
+}
+export interface ListClustersV2Request {
+    
+    ClusterNameFilter?: string;
+    
+    ClusterTypeFilter?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListClustersV2Request {
+    
+    const filterSensitiveLog: (obj: ListClustersV2Request) => any;
+}
+export interface ListClustersV2Response {
+    
+    ClusterInfoList?: Cluster[];
+    
+    NextToken?: string;
+}
+export declare namespace ListClustersV2Response {
+    
+    const filterSensitiveLog: (obj: ListClustersV2Response) => any;
+}
+export interface ListConfigurationRevisionsRequest {
+    
+    Arn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListConfigurationRevisionsRequest {
+    
+    const filterSensitiveLog: (obj: ListConfigurationRevisionsRequest) => any;
+}
+export interface ListConfigurationRevisionsResponse {
+    
+    NextToken?: string;
+    
+    Revisions?: ConfigurationRevision[];
+}
+export declare namespace ListConfigurationRevisionsResponse {
+    
+    const filterSensitiveLog: (obj: ListConfigurationRevisionsResponse) => any;
+}
+export interface ListConfigurationsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: ListConfigurationsRequest) => any;
+}
+export interface ListConfigurationsResponse {
+    
+    Configurations?: Configuration[];
+    
+    NextToken?: string;
+}
+export declare namespace ListConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: ListConfigurationsResponse) => any;
+}
+export interface ListKafkaVersionsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListKafkaVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListKafkaVersionsRequest) => any;
+}
+export interface ListKafkaVersionsResponse {
+    KafkaVersions?: KafkaVersion[];
+    NextToken?: string;
+}
+export declare namespace ListKafkaVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListKafkaVersionsResponse) => any;
+}
+export interface ListNodesRequest {
+    
+    ClusterArn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListNodesRequest {
+    
+    const filterSensitiveLog: (obj: ListNodesRequest) => any;
+}
+export interface ListNodesResponse {
+    
+    NextToken?: string;
+    
+    NodeInfoList?: NodeInfo[];
+}
+export declare namespace ListNodesResponse {
+    
+    const filterSensitiveLog: (obj: ListNodesResponse) => any;
+}
+export interface ListScramSecretsRequest {
+    
+    ClusterArn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListScramSecretsRequest {
+    
+    const filterSensitiveLog: (obj: ListScramSecretsRequest) => any;
+}
+export interface ListScramSecretsResponse {
+    
+    NextToken?: string;
+    
+    SecretArnList?: string[];
+}
+export declare namespace ListScramSecretsResponse {
+    
+    const filterSensitiveLog: (obj: ListScramSecretsResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+
+export interface RebootBrokerRequest {
+    
+    BrokerIds: string[] | undefined;
+    
+    ClusterArn: string | undefined;
+}
+export declare namespace RebootBrokerRequest {
+    
+    const filterSensitiveLog: (obj: RebootBrokerRequest) => any;
+}
+export interface RebootBrokerResponse {
+    
+    ClusterArn?: string;
+    
+    ClusterOperationArn?: string;
+}
+export declare namespace RebootBrokerResponse {
+    
+    const filterSensitiveLog: (obj: RebootBrokerResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UpdateBrokerCountRequest {
+    
+    ClusterArn: string | undefined;
+    
+    CurrentVersion: string | undefined;
+    
+    TargetNumberOfBrokerNodes: number | undefined;
+}
+export declare namespace UpdateBrokerCountRequest {
+    
+    const filterSensitiveLog: (obj: UpdateBrokerCountRequest) => any;
+}
+export interface UpdateBrokerCountResponse {
+    
+    ClusterArn?: string;
+    
+    ClusterOperationArn?: string;
+}
+export declare namespace UpdateBrokerCountResponse {
+    
+    const filterSensitiveLog: (obj: UpdateBrokerCountResponse) => any;
+}
+export interface UpdateBrokerStorageRequest {
+    
+    ClusterArn: string | undefined;
+    
+    CurrentVersion: string | undefined;
+    
+    TargetBrokerEBSVolumeInfo: BrokerEBSVolumeInfo[] | undefined;
+}
+export declare namespace UpdateBrokerStorageRequest {
+    
+    const filterSensitiveLog: (obj: UpdateBrokerStorageRequest) => any;
+}
+export interface UpdateBrokerStorageResponse {
+    
+    ClusterArn?: string;
+    
+    ClusterOperationArn?: string;
+}
+export declare namespace UpdateBrokerStorageResponse {
+    
+    const filterSensitiveLog: (obj: UpdateBrokerStorageResponse) => any;
+}
+export interface UpdateBrokerTypeRequest {
+    
+    ClusterArn: string | undefined;
+    
+    CurrentVersion: string | undefined;
+    
+    TargetInstanceType: string | undefined;
+}
+export declare namespace UpdateBrokerTypeRequest {
+    
+    const filterSensitiveLog: (obj: UpdateBrokerTypeRequest) => any;
+}
+export interface UpdateBrokerTypeResponse {
+    
+    ClusterArn?: string;
+    
+    ClusterOperationArn?: string;
+}
+export declare namespace UpdateBrokerTypeResponse {
+    
+    const filterSensitiveLog: (obj: UpdateBrokerTypeResponse) => any;
+}
+export interface UpdateClusterConfigurationRequest {
+    
+    ClusterArn: string | undefined;
+    
+    ConfigurationInfo: ConfigurationInfo | undefined;
+    
+    CurrentVersion: string | undefined;
+}
+export declare namespace UpdateClusterConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateClusterConfigurationRequest) => any;
+}
+export interface UpdateClusterConfigurationResponse {
+    
+    ClusterArn?: string;
+    
+    ClusterOperationArn?: string;
+}
+export declare namespace UpdateClusterConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateClusterConfigurationResponse) => any;
+}
+export interface UpdateClusterKafkaVersionRequest {
+    
+    ClusterArn: string | undefined;
+    
+    ConfigurationInfo?: ConfigurationInfo;
+    
+    CurrentVersion: string | undefined;
+    
+    TargetKafkaVersion: string | undefined;
+}
+export declare namespace UpdateClusterKafkaVersionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateClusterKafkaVersionRequest) => any;
+}
+export interface UpdateClusterKafkaVersionResponse {
+    
+    ClusterArn?: string;
+    
+    ClusterOperationArn?: string;
+}
+export declare namespace UpdateClusterKafkaVersionResponse {
+    
+    const filterSensitiveLog: (obj: UpdateClusterKafkaVersionResponse) => any;
+}
+export interface UpdateConfigurationRequest {
+    
+    Arn: string | undefined;
+    
+    Description?: string;
+    
+    ServerProperties: Uint8Array | undefined;
+}
+export declare namespace UpdateConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateConfigurationRequest) => any;
+}
+export interface UpdateConfigurationResponse {
+    
+    Arn?: string;
+    
+    LatestRevision?: ConfigurationRevision;
+}
+export declare namespace UpdateConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateConfigurationResponse) => any;
+}
+
+export interface UpdateConnectivityRequest {
+    
+    ClusterArn: string | undefined;
+    
+    ConnectivityInfo: ConnectivityInfo | undefined;
+    
+    CurrentVersion: string | undefined;
+}
+export declare namespace UpdateConnectivityRequest {
+    
+    const filterSensitiveLog: (obj: UpdateConnectivityRequest) => any;
+}
+export interface UpdateConnectivityResponse {
+    
+    ClusterArn?: string;
+    
+    ClusterOperationArn?: string;
+}
+export declare namespace UpdateConnectivityResponse {
+    
+    const filterSensitiveLog: (obj: UpdateConnectivityResponse) => any;
+}
+
+export interface UpdateMonitoringRequest {
+    
+    ClusterArn: string | undefined;
+    
+    CurrentVersion: string | undefined;
+    
+    EnhancedMonitoring?: EnhancedMonitoring | string;
+    
+    OpenMonitoring?: OpenMonitoringInfo;
+    LoggingInfo?: LoggingInfo;
+}
+export declare namespace UpdateMonitoringRequest {
+    
+    const filterSensitiveLog: (obj: UpdateMonitoringRequest) => any;
+}
+export interface UpdateMonitoringResponse {
+    
+    ClusterArn?: string;
+    
+    ClusterOperationArn?: string;
+}
+export declare namespace UpdateMonitoringResponse {
+    
+    const filterSensitiveLog: (obj: UpdateMonitoringResponse) => any;
+}
+export interface UpdateSecurityRequest {
+    
+    ClientAuthentication?: ClientAuthentication;
+    
+    ClusterArn: string | undefined;
+    
+    CurrentVersion: string | undefined;
+    
+    EncryptionInfo?: EncryptionInfo;
+}
+export declare namespace UpdateSecurityRequest {
+    
+    const filterSensitiveLog: (obj: UpdateSecurityRequest) => any;
+}
+export interface UpdateSecurityResponse {
+    
+    ClusterArn?: string;
+    
+    ClusterOperationArn?: string;
+}
+export declare namespace UpdateSecurityResponse {
+    
+    const filterSensitiveLog: (obj: UpdateSecurityResponse) => any;
+}