/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ /* * Do not modify this file. This file is generated from the kafka-2018-11-14.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.Kafka.Model; using Amazon.Kafka.Model.Internal.MarshallTransformations; using Amazon.Kafka.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.Kafka { ///

/// Implementation for accessing Kafka /// /// The operations for managing an Amazon MSK cluster. ///

public partial class AmazonKafkaClient : AmazonServiceClient, IAmazonKafka { private static IServiceMetadata serviceMetadata = new AmazonKafkaMetadata(); #if BCL45 || AWS_ASYNC_ENUMERABLES_API private IKafkaPaginatorFactory _paginators; ///

/// Paginators for the service ///

public IKafkaPaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new KafkaPaginatorFactory(this); } return this._paginators; } } #endif #region Constructors ///

/// Constructs AmazonKafkaClient with the credentials loaded from the application's /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. /// /// Example App.config with credentials set. ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

public AmazonKafkaClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonKafkaConfig()) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The region to connect. public AmazonKafkaClient(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonKafkaConfig{RegionEndpoint = region}) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The AmazonKafkaClient Configuration Object public AmazonKafkaClient(AmazonKafkaConfig config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} ///

/// Constructs AmazonKafkaClient with AWS Credentials ///

/// AWS Credentials public AmazonKafkaClient(AWSCredentials credentials) : this(credentials, new AmazonKafkaConfig()) { } ///

/// Constructs AmazonKafkaClient with AWS Credentials ///

/// AWS Credentials /// The region to connect. public AmazonKafkaClient(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonKafkaConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonKafkaClient with AWS Credentials and an /// AmazonKafkaClient Configuration object. ///

/// AWS Credentials /// The AmazonKafkaClient Configuration Object public AmazonKafkaClient(AWSCredentials credentials, AmazonKafkaConfig clientConfig) : base(credentials, clientConfig) { } ///

/// Constructs AmazonKafkaClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key public AmazonKafkaClient(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonKafkaConfig()) { } ///

/// Constructs AmazonKafkaClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonKafkaClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonKafkaConfig() {RegionEndpoint=region}) { } ///

/// Constructs AmazonKafkaClient with AWS Access Key ID, AWS Secret Key and an /// AmazonKafkaClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// The AmazonKafkaClient Configuration Object public AmazonKafkaClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonKafkaConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } ///

/// Constructs AmazonKafkaClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonKafkaClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonKafkaConfig()) { } ///

/// Constructs AmazonKafkaClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The region to connect. public AmazonKafkaClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonKafkaConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonKafkaClient with AWS Access Key ID, AWS Secret Key and an /// AmazonKafkaClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonKafkaClient Configuration Object public AmazonKafkaClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonKafkaConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig) { } #endregion #region Overrides ///

/// Creates the signer for the service. ///

protected override AbstractAWSSigner CreateSigner() { return new AWS4Signer(); } ///

/// Customize the pipeline ///

/// protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline) { pipeline.RemoveHandler(); pipeline.AddHandlerAfter(new AmazonKafkaEndpointResolver()); } ///

/// Capture metadata for the service. ///

protected override IServiceMetadata ServiceMetadata { get { return serviceMetadata; } } #endregion #region Dispose ///

/// Disposes the service client. ///

protected override void Dispose(bool disposing) { base.Dispose(disposing); } #endregion #region BatchAssociateScramSecret ///

/// Associates one or more Scram Secrets with an Amazon MSK cluster. ///

/// Container for the necessary parameters to execute the BatchAssociateScramSecret service method. /// /// The response from the BatchAssociateScramSecret service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for BatchAssociateScramSecret Operation public virtual BatchAssociateScramSecretResponse BatchAssociateScramSecret(BatchAssociateScramSecretRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = BatchAssociateScramSecretRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchAssociateScramSecretResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the BatchAssociateScramSecret operation. ///

/// /// Container for the necessary parameters to execute the BatchAssociateScramSecret operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchAssociateScramSecret /// operation. /// REST API Reference for BatchAssociateScramSecret Operation public virtual IAsyncResult BeginBatchAssociateScramSecret(BatchAssociateScramSecretRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = BatchAssociateScramSecretRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchAssociateScramSecretResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the BatchAssociateScramSecret operation. ///

/// /// The IAsyncResult returned by the call to BeginBatchAssociateScramSecret. /// /// Returns a BatchAssociateScramSecretResult from Kafka. /// REST API Reference for BatchAssociateScramSecret Operation public virtual BatchAssociateScramSecretResponse EndBatchAssociateScramSecret(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region BatchDisassociateScramSecret ///

/// Disassociates one or more Scram Secrets from an Amazon MSK cluster. ///

/// Container for the necessary parameters to execute the BatchDisassociateScramSecret service method. /// /// The response from the BatchDisassociateScramSecret service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for BatchDisassociateScramSecret Operation public virtual BatchDisassociateScramSecretResponse BatchDisassociateScramSecret(BatchDisassociateScramSecretRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = BatchDisassociateScramSecretRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchDisassociateScramSecretResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the BatchDisassociateScramSecret operation. ///

/// /// Container for the necessary parameters to execute the BatchDisassociateScramSecret operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchDisassociateScramSecret /// operation. /// REST API Reference for BatchDisassociateScramSecret Operation public virtual IAsyncResult BeginBatchDisassociateScramSecret(BatchDisassociateScramSecretRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = BatchDisassociateScramSecretRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchDisassociateScramSecretResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the BatchDisassociateScramSecret operation. ///

/// /// The IAsyncResult returned by the call to BeginBatchDisassociateScramSecret. /// /// Returns a BatchDisassociateScramSecretResult from Kafka. /// REST API Reference for BatchDisassociateScramSecret Operation public virtual BatchDisassociateScramSecretResponse EndBatchDisassociateScramSecret(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateCluster ///

/// Creates a new MSK cluster. ///

/// Container for the necessary parameters to execute the CreateCluster service method. /// /// The response from the CreateCluster service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for CreateCluster Operation public virtual CreateClusterResponse CreateCluster(CreateClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateCluster operation. ///

/// /// Container for the necessary parameters to execute the CreateCluster operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateCluster /// operation. /// REST API Reference for CreateCluster Operation public virtual IAsyncResult BeginCreateCluster(CreateClusterRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateCluster operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateCluster. /// /// Returns a CreateClusterResult from Kafka. /// REST API Reference for CreateCluster Operation public virtual CreateClusterResponse EndCreateCluster(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateClusterV2 ///

/// Creates a new MSK cluster. ///

/// Container for the necessary parameters to execute the CreateClusterV2 service method. /// /// The response from the CreateClusterV2 service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for CreateClusterV2 Operation public virtual CreateClusterV2Response CreateClusterV2(CreateClusterV2Request request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterV2RequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterV2ResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateClusterV2 operation. ///

/// /// Container for the necessary parameters to execute the CreateClusterV2 operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateClusterV2 /// operation. /// REST API Reference for CreateClusterV2 Operation public virtual IAsyncResult BeginCreateClusterV2(CreateClusterV2Request request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterV2RequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterV2ResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateClusterV2 operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateClusterV2. /// /// Returns a CreateClusterV2Result from Kafka. /// REST API Reference for CreateClusterV2 Operation public virtual CreateClusterV2Response EndCreateClusterV2(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateConfiguration ///

/// Creates a new MSK configuration. ///

/// Container for the necessary parameters to execute the CreateConfiguration service method. /// /// The response from the CreateConfiguration service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for CreateConfiguration Operation public virtual CreateConfigurationResponse CreateConfiguration(CreateConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateConfiguration operation. ///

/// /// Container for the necessary parameters to execute the CreateConfiguration operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateConfiguration /// operation. /// REST API Reference for CreateConfiguration Operation public virtual IAsyncResult BeginCreateConfiguration(CreateConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateConfiguration operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateConfiguration. /// /// Returns a CreateConfigurationResult from Kafka. /// REST API Reference for CreateConfiguration Operation public virtual CreateConfigurationResponse EndCreateConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateVpcConnection ///

/// Creates a new MSK VPC connection. ///

/// Container for the necessary parameters to execute the CreateVpcConnection service method. /// /// The response from the CreateVpcConnection service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for CreateVpcConnection Operation public virtual CreateVpcConnectionResponse CreateVpcConnection(CreateVpcConnectionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVpcConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVpcConnectionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateVpcConnection operation. ///

/// /// Container for the necessary parameters to execute the CreateVpcConnection operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVpcConnection /// operation. /// REST API Reference for CreateVpcConnection Operation public virtual IAsyncResult BeginCreateVpcConnection(CreateVpcConnectionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVpcConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVpcConnectionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateVpcConnection operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateVpcConnection. /// /// Returns a CreateVpcConnectionResult from Kafka. /// REST API Reference for CreateVpcConnection Operation public virtual CreateVpcConnectionResponse EndCreateVpcConnection(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteCluster ///

/// Deletes the MSK cluster specified by the Amazon Resource Name (ARN) in the request. ///

/// Container for the necessary parameters to execute the DeleteCluster service method. /// /// The response from the DeleteCluster service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for DeleteCluster Operation public virtual DeleteClusterResponse DeleteCluster(DeleteClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteCluster operation. ///

/// /// Container for the necessary parameters to execute the DeleteCluster operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteCluster /// operation. /// REST API Reference for DeleteCluster Operation public virtual IAsyncResult BeginDeleteCluster(DeleteClusterRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteCluster operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteCluster. /// /// Returns a DeleteClusterResult from Kafka. /// REST API Reference for DeleteCluster Operation public virtual DeleteClusterResponse EndDeleteCluster(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteClusterPolicy ///

/// Deletes the MSK cluster policy specified by the Amazon Resource Name (ARN) in the /// request. ///

/// Container for the necessary parameters to execute the DeleteClusterPolicy service method. /// /// The response from the DeleteClusterPolicy service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for DeleteClusterPolicy Operation public virtual DeleteClusterPolicyResponse DeleteClusterPolicy(DeleteClusterPolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterPolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteClusterPolicy operation. ///

/// /// Container for the necessary parameters to execute the DeleteClusterPolicy operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteClusterPolicy /// operation. /// REST API Reference for DeleteClusterPolicy Operation public virtual IAsyncResult BeginDeleteClusterPolicy(DeleteClusterPolicyRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterPolicyResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteClusterPolicy operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteClusterPolicy. /// /// Returns a DeleteClusterPolicyResult from Kafka. /// REST API Reference for DeleteClusterPolicy Operation public virtual DeleteClusterPolicyResponse EndDeleteClusterPolicy(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteConfiguration ///

/// Deletes an MSK Configuration. ///

/// Container for the necessary parameters to execute the DeleteConfiguration service method. /// /// The response from the DeleteConfiguration service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for DeleteConfiguration Operation public virtual DeleteConfigurationResponse DeleteConfiguration(DeleteConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteConfiguration operation. ///

/// /// Container for the necessary parameters to execute the DeleteConfiguration operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteConfiguration /// operation. /// REST API Reference for DeleteConfiguration Operation public virtual IAsyncResult BeginDeleteConfiguration(DeleteConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteConfiguration operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteConfiguration. /// /// Returns a DeleteConfigurationResult from Kafka. /// REST API Reference for DeleteConfiguration Operation public virtual DeleteConfigurationResponse EndDeleteConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteVpcConnection ///

/// Deletes a MSK VPC connection. ///

/// Container for the necessary parameters to execute the DeleteVpcConnection service method. /// /// The response from the DeleteVpcConnection service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for DeleteVpcConnection Operation public virtual DeleteVpcConnectionResponse DeleteVpcConnection(DeleteVpcConnectionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteVpcConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteVpcConnectionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteVpcConnection operation. ///

/// /// Container for the necessary parameters to execute the DeleteVpcConnection operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVpcConnection /// operation. /// REST API Reference for DeleteVpcConnection Operation public virtual IAsyncResult BeginDeleteVpcConnection(DeleteVpcConnectionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteVpcConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteVpcConnectionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteVpcConnection operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteVpcConnection. /// /// Returns a DeleteVpcConnectionResult from Kafka. /// REST API Reference for DeleteVpcConnection Operation public virtual DeleteVpcConnectionResponse EndDeleteVpcConnection(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeCluster ///

/// Returns a description of the MSK cluster whose Amazon Resource Name (ARN) is specified /// in the request. ///

/// Container for the necessary parameters to execute the DescribeCluster service method. /// /// The response from the DescribeCluster service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for DescribeCluster Operation public virtual DescribeClusterResponse DescribeCluster(DescribeClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeCluster operation. ///

/// /// Container for the necessary parameters to execute the DescribeCluster operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeCluster /// operation. /// REST API Reference for DescribeCluster Operation public virtual IAsyncResult BeginDescribeCluster(DescribeClusterRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeCluster operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeCluster. /// /// Returns a DescribeClusterResult from Kafka. /// REST API Reference for DescribeCluster Operation public virtual DescribeClusterResponse EndDescribeCluster(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeClusterOperation ///

/// Returns a description of the cluster operation specified by the ARN. ///

/// Container for the necessary parameters to execute the DescribeClusterOperation service method. /// /// The response from the DescribeClusterOperation service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for DescribeClusterOperation Operation public virtual DescribeClusterOperationResponse DescribeClusterOperation(DescribeClusterOperationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterOperationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterOperationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeClusterOperation operation. ///

/// /// Container for the necessary parameters to execute the DescribeClusterOperation operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeClusterOperation /// operation. /// REST API Reference for DescribeClusterOperation Operation public virtual IAsyncResult BeginDescribeClusterOperation(DescribeClusterOperationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterOperationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterOperationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeClusterOperation operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeClusterOperation. /// /// Returns a DescribeClusterOperationResult from Kafka. /// REST API Reference for DescribeClusterOperation Operation public virtual DescribeClusterOperationResponse EndDescribeClusterOperation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeClusterOperationV2 ///

/// Returns a description of the cluster operation specified by the ARN. ///

/// Container for the necessary parameters to execute the DescribeClusterOperationV2 service method. /// /// The response from the DescribeClusterOperationV2 service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for DescribeClusterOperationV2 Operation public virtual DescribeClusterOperationV2Response DescribeClusterOperationV2(DescribeClusterOperationV2Request request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterOperationV2RequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterOperationV2ResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeClusterOperationV2 operation. ///

/// /// Container for the necessary parameters to execute the DescribeClusterOperationV2 operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeClusterOperationV2 /// operation. /// REST API Reference for DescribeClusterOperationV2 Operation public virtual IAsyncResult BeginDescribeClusterOperationV2(DescribeClusterOperationV2Request request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterOperationV2RequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterOperationV2ResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeClusterOperationV2 operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeClusterOperationV2. /// /// Returns a DescribeClusterOperationV2Result from Kafka. /// REST API Reference for DescribeClusterOperationV2 Operation public virtual DescribeClusterOperationV2Response EndDescribeClusterOperationV2(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeClusterV2 ///

/// Returns a description of the MSK cluster whose Amazon Resource Name (ARN) is specified /// in the request. ///

/// Container for the necessary parameters to execute the DescribeClusterV2 service method. /// /// The response from the DescribeClusterV2 service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for DescribeClusterV2 Operation public virtual DescribeClusterV2Response DescribeClusterV2(DescribeClusterV2Request request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterV2RequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterV2ResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeClusterV2 operation. ///

/// /// Container for the necessary parameters to execute the DescribeClusterV2 operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeClusterV2 /// operation. /// REST API Reference for DescribeClusterV2 Operation public virtual IAsyncResult BeginDescribeClusterV2(DescribeClusterV2Request request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterV2RequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterV2ResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeClusterV2 operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeClusterV2. /// /// Returns a DescribeClusterV2Result from Kafka. /// REST API Reference for DescribeClusterV2 Operation public virtual DescribeClusterV2Response EndDescribeClusterV2(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeConfiguration ///

/// Returns a description of this MSK configuration. ///

/// Container for the necessary parameters to execute the DescribeConfiguration service method. /// /// The response from the DescribeConfiguration service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for DescribeConfiguration Operation public virtual DescribeConfigurationResponse DescribeConfiguration(DescribeConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeConfiguration operation. ///

/// /// Container for the necessary parameters to execute the DescribeConfiguration operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeConfiguration /// operation. /// REST API Reference for DescribeConfiguration Operation public virtual IAsyncResult BeginDescribeConfiguration(DescribeConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeConfiguration operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeConfiguration. /// /// Returns a DescribeConfigurationResult from Kafka. /// REST API Reference for DescribeConfiguration Operation public virtual DescribeConfigurationResponse EndDescribeConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeConfigurationRevision ///

/// Returns a description of this revision of the configuration. ///

/// Container for the necessary parameters to execute the DescribeConfigurationRevision service method. /// /// The response from the DescribeConfigurationRevision service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for DescribeConfigurationRevision Operation public virtual DescribeConfigurationRevisionResponse DescribeConfigurationRevision(DescribeConfigurationRevisionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeConfigurationRevisionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeConfigurationRevisionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeConfigurationRevision operation. ///

/// /// Container for the necessary parameters to execute the DescribeConfigurationRevision operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeConfigurationRevision /// operation. /// REST API Reference for DescribeConfigurationRevision Operation public virtual IAsyncResult BeginDescribeConfigurationRevision(DescribeConfigurationRevisionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeConfigurationRevisionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeConfigurationRevisionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeConfigurationRevision operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeConfigurationRevision. /// /// Returns a DescribeConfigurationRevisionResult from Kafka. /// REST API Reference for DescribeConfigurationRevision Operation public virtual DescribeConfigurationRevisionResponse EndDescribeConfigurationRevision(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeVpcConnection ///

/// Returns a description of this MSK VPC connection. ///

/// Container for the necessary parameters to execute the DescribeVpcConnection service method. /// /// The response from the DescribeVpcConnection service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for DescribeVpcConnection Operation public virtual DescribeVpcConnectionResponse DescribeVpcConnection(DescribeVpcConnectionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeVpcConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeVpcConnectionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeVpcConnection operation. ///

/// /// Container for the necessary parameters to execute the DescribeVpcConnection operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpcConnection /// operation. /// REST API Reference for DescribeVpcConnection Operation public virtual IAsyncResult BeginDescribeVpcConnection(DescribeVpcConnectionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeVpcConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeVpcConnectionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeVpcConnection operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeVpcConnection. /// /// Returns a DescribeVpcConnectionResult from Kafka. /// REST API Reference for DescribeVpcConnection Operation public virtual DescribeVpcConnectionResponse EndDescribeVpcConnection(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetBootstrapBrokers ///

/// A list of brokers that a client application can use to bootstrap. ///

/// Container for the necessary parameters to execute the GetBootstrapBrokers service method. /// /// The response from the GetBootstrapBrokers service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for GetBootstrapBrokers Operation public virtual GetBootstrapBrokersResponse GetBootstrapBrokers(GetBootstrapBrokersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetBootstrapBrokersRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBootstrapBrokersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetBootstrapBrokers operation. ///

/// /// Container for the necessary parameters to execute the GetBootstrapBrokers operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetBootstrapBrokers /// operation. /// REST API Reference for GetBootstrapBrokers Operation public virtual IAsyncResult BeginGetBootstrapBrokers(GetBootstrapBrokersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetBootstrapBrokersRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBootstrapBrokersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetBootstrapBrokers operation. ///

/// /// The IAsyncResult returned by the call to BeginGetBootstrapBrokers. /// /// Returns a GetBootstrapBrokersResult from Kafka. /// REST API Reference for GetBootstrapBrokers Operation public virtual GetBootstrapBrokersResponse EndGetBootstrapBrokers(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetClusterPolicy ///

/// Get the MSK cluster policy specified by the Amazon Resource Name (ARN) in the request. ///

/// Container for the necessary parameters to execute the GetClusterPolicy service method. /// /// The response from the GetClusterPolicy service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for GetClusterPolicy Operation public virtual GetClusterPolicyResponse GetClusterPolicy(GetClusterPolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetClusterPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = GetClusterPolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetClusterPolicy operation. ///

/// /// Container for the necessary parameters to execute the GetClusterPolicy operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetClusterPolicy /// operation. /// REST API Reference for GetClusterPolicy Operation public virtual IAsyncResult BeginGetClusterPolicy(GetClusterPolicyRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetClusterPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = GetClusterPolicyResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetClusterPolicy operation. ///

/// /// The IAsyncResult returned by the call to BeginGetClusterPolicy. /// /// Returns a GetClusterPolicyResult from Kafka. /// REST API Reference for GetClusterPolicy Operation public virtual GetClusterPolicyResponse EndGetClusterPolicy(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetCompatibleKafkaVersions ///

/// Gets the Apache Kafka versions to which you can update the MSK cluster. ///

/// Container for the necessary parameters to execute the GetCompatibleKafkaVersions service method. /// /// The response from the GetCompatibleKafkaVersions service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for GetCompatibleKafkaVersions Operation public virtual GetCompatibleKafkaVersionsResponse GetCompatibleKafkaVersions(GetCompatibleKafkaVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCompatibleKafkaVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCompatibleKafkaVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetCompatibleKafkaVersions operation. ///

/// /// Container for the necessary parameters to execute the GetCompatibleKafkaVersions operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCompatibleKafkaVersions /// operation. /// REST API Reference for GetCompatibleKafkaVersions Operation public virtual IAsyncResult BeginGetCompatibleKafkaVersions(GetCompatibleKafkaVersionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetCompatibleKafkaVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCompatibleKafkaVersionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetCompatibleKafkaVersions operation. ///

/// /// The IAsyncResult returned by the call to BeginGetCompatibleKafkaVersions. /// /// Returns a GetCompatibleKafkaVersionsResult from Kafka. /// REST API Reference for GetCompatibleKafkaVersions Operation public virtual GetCompatibleKafkaVersionsResponse EndGetCompatibleKafkaVersions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListClientVpcConnections ///

/// Returns a list of all the VPC connections in this Region. ///

/// Container for the necessary parameters to execute the ListClientVpcConnections service method. /// /// The response from the ListClientVpcConnections service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for ListClientVpcConnections Operation public virtual ListClientVpcConnectionsResponse ListClientVpcConnections(ListClientVpcConnectionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListClientVpcConnectionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListClientVpcConnectionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListClientVpcConnections operation. ///

/// /// Container for the necessary parameters to execute the ListClientVpcConnections operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListClientVpcConnections /// operation. /// REST API Reference for ListClientVpcConnections Operation public virtual IAsyncResult BeginListClientVpcConnections(ListClientVpcConnectionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListClientVpcConnectionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListClientVpcConnectionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListClientVpcConnections operation. ///

/// /// The IAsyncResult returned by the call to BeginListClientVpcConnections. /// /// Returns a ListClientVpcConnectionsResult from Kafka. /// REST API Reference for ListClientVpcConnections Operation public virtual ListClientVpcConnectionsResponse EndListClientVpcConnections(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListClusterOperations ///

/// Returns a list of all the operations that have been performed on the specified MSK /// cluster. ///

/// Container for the necessary parameters to execute the ListClusterOperations service method. /// /// The response from the ListClusterOperations service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for ListClusterOperations Operation public virtual ListClusterOperationsResponse ListClusterOperations(ListClusterOperationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListClusterOperationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListClusterOperationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListClusterOperations operation. ///

/// /// Container for the necessary parameters to execute the ListClusterOperations operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListClusterOperations /// operation. /// REST API Reference for ListClusterOperations Operation public virtual IAsyncResult BeginListClusterOperations(ListClusterOperationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListClusterOperationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListClusterOperationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListClusterOperations operation. ///

/// /// The IAsyncResult returned by the call to BeginListClusterOperations. /// /// Returns a ListClusterOperationsResult from Kafka. /// REST API Reference for ListClusterOperations Operation public virtual ListClusterOperationsResponse EndListClusterOperations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListClusterOperationsV2 ///

/// Returns a list of all the operations that have been performed on the specified MSK /// cluster. ///

/// Container for the necessary parameters to execute the ListClusterOperationsV2 service method. /// /// The response from the ListClusterOperationsV2 service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for ListClusterOperationsV2 Operation public virtual ListClusterOperationsV2Response ListClusterOperationsV2(ListClusterOperationsV2Request request) { var options = new InvokeOptions(); options.RequestMarshaller = ListClusterOperationsV2RequestMarshaller.Instance; options.ResponseUnmarshaller = ListClusterOperationsV2ResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListClusterOperationsV2 operation. ///

/// /// Container for the necessary parameters to execute the ListClusterOperationsV2 operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListClusterOperationsV2 /// operation. /// REST API Reference for ListClusterOperationsV2 Operation public virtual IAsyncResult BeginListClusterOperationsV2(ListClusterOperationsV2Request request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListClusterOperationsV2RequestMarshaller.Instance; options.ResponseUnmarshaller = ListClusterOperationsV2ResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListClusterOperationsV2 operation. ///

/// /// The IAsyncResult returned by the call to BeginListClusterOperationsV2. /// /// Returns a ListClusterOperationsV2Result from Kafka. /// REST API Reference for ListClusterOperationsV2 Operation public virtual ListClusterOperationsV2Response EndListClusterOperationsV2(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListClusters ///

/// Returns a list of all the MSK clusters in the current Region. ///

/// Container for the necessary parameters to execute the ListClusters service method. /// /// The response from the ListClusters service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for ListClusters Operation public virtual ListClustersResponse ListClusters(ListClustersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListClustersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListClustersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListClusters operation. ///

/// /// Container for the necessary parameters to execute the ListClusters operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListClusters /// operation. /// REST API Reference for ListClusters Operation public virtual IAsyncResult BeginListClusters(ListClustersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListClustersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListClustersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListClusters operation. ///

/// /// The IAsyncResult returned by the call to BeginListClusters. /// /// Returns a ListClustersResult from Kafka. /// REST API Reference for ListClusters Operation public virtual ListClustersResponse EndListClusters(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListClustersV2 ///

/// Returns a list of all the MSK clusters in the current Region. ///

/// Container for the necessary parameters to execute the ListClustersV2 service method. /// /// The response from the ListClustersV2 service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for ListClustersV2 Operation public virtual ListClustersV2Response ListClustersV2(ListClustersV2Request request) { var options = new InvokeOptions(); options.RequestMarshaller = ListClustersV2RequestMarshaller.Instance; options.ResponseUnmarshaller = ListClustersV2ResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListClustersV2 operation. ///

/// /// Container for the necessary parameters to execute the ListClustersV2 operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListClustersV2 /// operation. /// REST API Reference for ListClustersV2 Operation public virtual IAsyncResult BeginListClustersV2(ListClustersV2Request request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListClustersV2RequestMarshaller.Instance; options.ResponseUnmarshaller = ListClustersV2ResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListClustersV2 operation. ///

/// /// The IAsyncResult returned by the call to BeginListClustersV2. /// /// Returns a ListClustersV2Result from Kafka. /// REST API Reference for ListClustersV2 Operation public virtual ListClustersV2Response EndListClustersV2(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListConfigurationRevisions ///

/// Returns a list of all the MSK configurations in this Region. ///

/// Container for the necessary parameters to execute the ListConfigurationRevisions service method. /// /// The response from the ListConfigurationRevisions service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for ListConfigurationRevisions Operation public virtual ListConfigurationRevisionsResponse ListConfigurationRevisions(ListConfigurationRevisionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListConfigurationRevisionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListConfigurationRevisionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListConfigurationRevisions operation. ///

/// /// Container for the necessary parameters to execute the ListConfigurationRevisions operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListConfigurationRevisions /// operation. /// REST API Reference for ListConfigurationRevisions Operation public virtual IAsyncResult BeginListConfigurationRevisions(ListConfigurationRevisionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListConfigurationRevisionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListConfigurationRevisionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListConfigurationRevisions operation. ///

/// /// The IAsyncResult returned by the call to BeginListConfigurationRevisions. /// /// Returns a ListConfigurationRevisionsResult from Kafka. /// REST API Reference for ListConfigurationRevisions Operation public virtual ListConfigurationRevisionsResponse EndListConfigurationRevisions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListConfigurations ///

/// Returns a list of all the MSK configurations in this Region. ///

/// Container for the necessary parameters to execute the ListConfigurations service method. /// /// The response from the ListConfigurations service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for ListConfigurations Operation public virtual ListConfigurationsResponse ListConfigurations(ListConfigurationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListConfigurationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListConfigurationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListConfigurations operation. ///

/// /// Container for the necessary parameters to execute the ListConfigurations operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListConfigurations /// operation. /// REST API Reference for ListConfigurations Operation public virtual IAsyncResult BeginListConfigurations(ListConfigurationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListConfigurationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListConfigurationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListConfigurations operation. ///

/// /// The IAsyncResult returned by the call to BeginListConfigurations. /// /// Returns a ListConfigurationsResult from Kafka. /// REST API Reference for ListConfigurations Operation public virtual ListConfigurationsResponse EndListConfigurations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListKafkaVersions ///

/// Returns a list of Apache Kafka versions. ///

/// Container for the necessary parameters to execute the ListKafkaVersions service method. /// /// The response from the ListKafkaVersions service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for ListKafkaVersions Operation public virtual ListKafkaVersionsResponse ListKafkaVersions(ListKafkaVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListKafkaVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListKafkaVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListKafkaVersions operation. ///

/// /// Container for the necessary parameters to execute the ListKafkaVersions operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListKafkaVersions /// operation. /// REST API Reference for ListKafkaVersions Operation public virtual IAsyncResult BeginListKafkaVersions(ListKafkaVersionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListKafkaVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListKafkaVersionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListKafkaVersions operation. ///

/// /// The IAsyncResult returned by the call to BeginListKafkaVersions. /// /// Returns a ListKafkaVersionsResult from Kafka. /// REST API Reference for ListKafkaVersions Operation public virtual ListKafkaVersionsResponse EndListKafkaVersions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListNodes ///

/// Returns a list of the broker nodes in the cluster. ///

/// Container for the necessary parameters to execute the ListNodes service method. /// /// The response from the ListNodes service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for ListNodes Operation public virtual ListNodesResponse ListNodes(ListNodesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListNodesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListNodesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListNodes operation. ///

/// /// Container for the necessary parameters to execute the ListNodes operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListNodes /// operation. /// REST API Reference for ListNodes Operation public virtual IAsyncResult BeginListNodes(ListNodesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListNodesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListNodesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListNodes operation. ///

/// /// The IAsyncResult returned by the call to BeginListNodes. /// /// Returns a ListNodesResult from Kafka. /// REST API Reference for ListNodes Operation public virtual ListNodesResponse EndListNodes(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListScramSecrets ///

/// Returns a list of the Scram Secrets associated with an Amazon MSK cluster. ///

/// Container for the necessary parameters to execute the ListScramSecrets service method. /// /// The response from the ListScramSecrets service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for ListScramSecrets Operation public virtual ListScramSecretsResponse ListScramSecrets(ListScramSecretsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListScramSecretsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListScramSecretsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListScramSecrets operation. ///

/// /// Container for the necessary parameters to execute the ListScramSecrets operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListScramSecrets /// operation. /// REST API Reference for ListScramSecrets Operation public virtual IAsyncResult BeginListScramSecrets(ListScramSecretsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListScramSecretsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListScramSecretsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListScramSecrets operation. ///

/// /// The IAsyncResult returned by the call to BeginListScramSecrets. /// /// Returns a ListScramSecretsResult from Kafka. /// REST API Reference for ListScramSecrets Operation public virtual ListScramSecretsResponse EndListScramSecrets(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTagsForResource ///

/// Returns a list of the tags associated with the specified resource. ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListTagsForResource operation. ///

/// /// Container for the necessary parameters to execute the ListTagsForResource operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTagsForResource /// operation. /// REST API Reference for ListTagsForResource Operation public virtual IAsyncResult BeginListTagsForResource(ListTagsForResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListTagsForResource operation. ///

/// /// The IAsyncResult returned by the call to BeginListTagsForResource. /// /// Returns a ListTagsForResourceResult from Kafka. /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListVpcConnections ///

/// Returns a list of all the VPC connections in this Region. ///

/// Container for the necessary parameters to execute the ListVpcConnections service method. /// /// The response from the ListVpcConnections service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for ListVpcConnections Operation public virtual ListVpcConnectionsResponse ListVpcConnections(ListVpcConnectionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListVpcConnectionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListVpcConnectionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListVpcConnections operation. ///

/// /// Container for the necessary parameters to execute the ListVpcConnections operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListVpcConnections /// operation. /// REST API Reference for ListVpcConnections Operation public virtual IAsyncResult BeginListVpcConnections(ListVpcConnectionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListVpcConnectionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListVpcConnectionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListVpcConnections operation. ///

/// /// The IAsyncResult returned by the call to BeginListVpcConnections. /// /// Returns a ListVpcConnectionsResult from Kafka. /// REST API Reference for ListVpcConnections Operation public virtual ListVpcConnectionsResponse EndListVpcConnections(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region PutClusterPolicy ///

/// Creates or updates the MSK cluster policy specified by the cluster Amazon Resource /// Name (ARN) in the request. ///

/// Container for the necessary parameters to execute the PutClusterPolicy service method. /// /// The response from the PutClusterPolicy service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for PutClusterPolicy Operation public virtual PutClusterPolicyResponse PutClusterPolicy(PutClusterPolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutClusterPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutClusterPolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the PutClusterPolicy operation. ///

/// /// Container for the necessary parameters to execute the PutClusterPolicy operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutClusterPolicy /// operation. /// REST API Reference for PutClusterPolicy Operation public virtual IAsyncResult BeginPutClusterPolicy(PutClusterPolicyRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = PutClusterPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutClusterPolicyResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the PutClusterPolicy operation. ///

/// /// The IAsyncResult returned by the call to BeginPutClusterPolicy. /// /// Returns a PutClusterPolicyResult from Kafka. /// REST API Reference for PutClusterPolicy Operation public virtual PutClusterPolicyResponse EndPutClusterPolicy(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RebootBroker ///

/// Reboots brokers. ///

/// Container for the necessary parameters to execute the RebootBroker service method. /// /// The response from the RebootBroker service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for RebootBroker Operation public virtual RebootBrokerResponse RebootBroker(RebootBrokerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RebootBrokerRequestMarshaller.Instance; options.ResponseUnmarshaller = RebootBrokerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RebootBroker operation. ///

/// /// Container for the necessary parameters to execute the RebootBroker operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRebootBroker /// operation. /// REST API Reference for RebootBroker Operation public virtual IAsyncResult BeginRebootBroker(RebootBrokerRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RebootBrokerRequestMarshaller.Instance; options.ResponseUnmarshaller = RebootBrokerResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RebootBroker operation. ///

/// /// The IAsyncResult returned by the call to BeginRebootBroker. /// /// Returns a RebootBrokerResult from Kafka. /// REST API Reference for RebootBroker Operation public virtual RebootBrokerResponse EndRebootBroker(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RejectClientVpcConnection ///

/// Returns empty response. ///

/// Container for the necessary parameters to execute the RejectClientVpcConnection service method. /// /// The response from the RejectClientVpcConnection service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for RejectClientVpcConnection Operation public virtual RejectClientVpcConnectionResponse RejectClientVpcConnection(RejectClientVpcConnectionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RejectClientVpcConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectClientVpcConnectionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RejectClientVpcConnection operation. ///

/// /// Container for the necessary parameters to execute the RejectClientVpcConnection operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRejectClientVpcConnection /// operation. /// REST API Reference for RejectClientVpcConnection Operation public virtual IAsyncResult BeginRejectClientVpcConnection(RejectClientVpcConnectionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RejectClientVpcConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectClientVpcConnectionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RejectClientVpcConnection operation. ///

/// /// The IAsyncResult returned by the call to BeginRejectClientVpcConnection. /// /// Returns a RejectClientVpcConnectionResult from Kafka. /// REST API Reference for RejectClientVpcConnection Operation public virtual RejectClientVpcConnectionResponse EndRejectClientVpcConnection(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TagResource ///

/// Adds tags to the specified MSK resource. ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for TagResource Operation public virtual TagResourceResponse TagResource(TagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the TagResource operation. ///

/// /// Container for the necessary parameters to execute the TagResource operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTagResource /// operation. /// REST API Reference for TagResource Operation public virtual IAsyncResult BeginTagResource(TagResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the TagResource operation. ///

/// /// The IAsyncResult returned by the call to BeginTagResource. /// /// Returns a TagResourceResult from Kafka. /// REST API Reference for TagResource Operation public virtual TagResourceResponse EndTagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UntagResource ///

/// Removes the tags associated with the keys that are provided in the query. ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse UntagResource(UntagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UntagResource operation. ///

/// /// Container for the necessary parameters to execute the UntagResource operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUntagResource /// operation. /// REST API Reference for UntagResource Operation public virtual IAsyncResult BeginUntagResource(UntagResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UntagResource operation. ///

/// /// The IAsyncResult returned by the call to BeginUntagResource. /// /// Returns a UntagResourceResult from Kafka. /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse EndUntagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateBrokerCount ///

/// Updates the number of broker nodes in the cluster. ///

/// Container for the necessary parameters to execute the UpdateBrokerCount service method. /// /// The response from the UpdateBrokerCount service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for UpdateBrokerCount Operation public virtual UpdateBrokerCountResponse UpdateBrokerCount(UpdateBrokerCountRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateBrokerCountRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateBrokerCountResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateBrokerCount operation. ///

/// /// Container for the necessary parameters to execute the UpdateBrokerCount operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateBrokerCount /// operation. /// REST API Reference for UpdateBrokerCount Operation public virtual IAsyncResult BeginUpdateBrokerCount(UpdateBrokerCountRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateBrokerCountRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateBrokerCountResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateBrokerCount operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateBrokerCount. /// /// Returns a UpdateBrokerCountResult from Kafka. /// REST API Reference for UpdateBrokerCount Operation public virtual UpdateBrokerCountResponse EndUpdateBrokerCount(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateBrokerStorage ///

/// Updates the EBS storage associated with MSK brokers. ///

/// Container for the necessary parameters to execute the UpdateBrokerStorage service method. /// /// The response from the UpdateBrokerStorage service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for UpdateBrokerStorage Operation public virtual UpdateBrokerStorageResponse UpdateBrokerStorage(UpdateBrokerStorageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateBrokerStorageRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateBrokerStorageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateBrokerStorage operation. ///

/// /// Container for the necessary parameters to execute the UpdateBrokerStorage operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateBrokerStorage /// operation. /// REST API Reference for UpdateBrokerStorage Operation public virtual IAsyncResult BeginUpdateBrokerStorage(UpdateBrokerStorageRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateBrokerStorageRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateBrokerStorageResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateBrokerStorage operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateBrokerStorage. /// /// Returns a UpdateBrokerStorageResult from Kafka. /// REST API Reference for UpdateBrokerStorage Operation public virtual UpdateBrokerStorageResponse EndUpdateBrokerStorage(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateBrokerType ///

/// Updates EC2 instance type. ///

/// Container for the necessary parameters to execute the UpdateBrokerType service method. /// /// The response from the UpdateBrokerType service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for UpdateBrokerType Operation public virtual UpdateBrokerTypeResponse UpdateBrokerType(UpdateBrokerTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateBrokerTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateBrokerTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateBrokerType operation. ///

/// /// Container for the necessary parameters to execute the UpdateBrokerType operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateBrokerType /// operation. /// REST API Reference for UpdateBrokerType Operation public virtual IAsyncResult BeginUpdateBrokerType(UpdateBrokerTypeRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateBrokerTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateBrokerTypeResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateBrokerType operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateBrokerType. /// /// Returns a UpdateBrokerTypeResult from Kafka. /// REST API Reference for UpdateBrokerType Operation public virtual UpdateBrokerTypeResponse EndUpdateBrokerType(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateClusterConfiguration ///

/// Updates the cluster with the configuration that is specified in the request body. ///

/// Container for the necessary parameters to execute the UpdateClusterConfiguration service method. /// /// The response from the UpdateClusterConfiguration service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for UpdateClusterConfiguration Operation public virtual UpdateClusterConfigurationResponse UpdateClusterConfiguration(UpdateClusterConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateClusterConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateClusterConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateClusterConfiguration operation. ///

/// /// Container for the necessary parameters to execute the UpdateClusterConfiguration operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateClusterConfiguration /// operation. /// REST API Reference for UpdateClusterConfiguration Operation public virtual IAsyncResult BeginUpdateClusterConfiguration(UpdateClusterConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateClusterConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateClusterConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateClusterConfiguration operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateClusterConfiguration. /// /// Returns a UpdateClusterConfigurationResult from Kafka. /// REST API Reference for UpdateClusterConfiguration Operation public virtual UpdateClusterConfigurationResponse EndUpdateClusterConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateClusterKafkaVersion ///

/// Updates the Apache Kafka version for the cluster. ///

/// Container for the necessary parameters to execute the UpdateClusterKafkaVersion service method. /// /// The response from the UpdateClusterKafkaVersion service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for UpdateClusterKafkaVersion Operation public virtual UpdateClusterKafkaVersionResponse UpdateClusterKafkaVersion(UpdateClusterKafkaVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateClusterKafkaVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateClusterKafkaVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateClusterKafkaVersion operation. ///

/// /// Container for the necessary parameters to execute the UpdateClusterKafkaVersion operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateClusterKafkaVersion /// operation. /// REST API Reference for UpdateClusterKafkaVersion Operation public virtual IAsyncResult BeginUpdateClusterKafkaVersion(UpdateClusterKafkaVersionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateClusterKafkaVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateClusterKafkaVersionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateClusterKafkaVersion operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateClusterKafkaVersion. /// /// Returns a UpdateClusterKafkaVersionResult from Kafka. /// REST API Reference for UpdateClusterKafkaVersion Operation public virtual UpdateClusterKafkaVersionResponse EndUpdateClusterKafkaVersion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateConfiguration ///

/// Updates an MSK configuration. ///

/// Container for the necessary parameters to execute the UpdateConfiguration service method. /// /// The response from the UpdateConfiguration service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for UpdateConfiguration Operation public virtual UpdateConfigurationResponse UpdateConfiguration(UpdateConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateConfiguration operation. ///

/// /// Container for the necessary parameters to execute the UpdateConfiguration operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateConfiguration /// operation. /// REST API Reference for UpdateConfiguration Operation public virtual IAsyncResult BeginUpdateConfiguration(UpdateConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateConfiguration operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateConfiguration. /// /// Returns a UpdateConfigurationResult from Kafka. /// REST API Reference for UpdateConfiguration Operation public virtual UpdateConfigurationResponse EndUpdateConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateConnectivity ///

/// Updates the cluster's connectivity configuration. ///

/// Container for the necessary parameters to execute the UpdateConnectivity service method. /// /// The response from the UpdateConnectivity service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for UpdateConnectivity Operation public virtual UpdateConnectivityResponse UpdateConnectivity(UpdateConnectivityRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConnectivityRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConnectivityResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateConnectivity operation. ///

/// /// Container for the necessary parameters to execute the UpdateConnectivity operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateConnectivity /// operation. /// REST API Reference for UpdateConnectivity Operation public virtual IAsyncResult BeginUpdateConnectivity(UpdateConnectivityRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConnectivityRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConnectivityResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateConnectivity operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateConnectivity. /// /// Returns a UpdateConnectivityResult from Kafka. /// REST API Reference for UpdateConnectivity Operation public virtual UpdateConnectivityResponse EndUpdateConnectivity(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateMonitoring ///

/// Updates the monitoring settings for the cluster. You can use this operation to specify /// which Apache Kafka metrics you want Amazon MSK to send to Amazon CloudWatch. You can /// also specify settings for open monitoring with Prometheus. ///

/// Container for the necessary parameters to execute the UpdateMonitoring service method. /// /// The response from the UpdateMonitoring service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for UpdateMonitoring Operation public virtual UpdateMonitoringResponse UpdateMonitoring(UpdateMonitoringRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateMonitoringRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateMonitoringResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateMonitoring operation. ///

/// /// Container for the necessary parameters to execute the UpdateMonitoring operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateMonitoring /// operation. /// REST API Reference for UpdateMonitoring Operation public virtual IAsyncResult BeginUpdateMonitoring(UpdateMonitoringRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateMonitoringRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateMonitoringResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateMonitoring operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateMonitoring. /// /// Returns a UpdateMonitoringResult from Kafka. /// REST API Reference for UpdateMonitoring Operation public virtual UpdateMonitoringResponse EndUpdateMonitoring(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateSecurity ///

/// Updates the security settings for the cluster. You can use this operation to specify /// encryption and authentication on existing clusters. ///

/// Container for the necessary parameters to execute the UpdateSecurity service method. /// /// The response from the UpdateSecurity service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for UpdateSecurity Operation public virtual UpdateSecurityResponse UpdateSecurity(UpdateSecurityRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSecurityRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSecurityResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateSecurity operation. ///

/// /// Container for the necessary parameters to execute the UpdateSecurity operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateSecurity /// operation. /// REST API Reference for UpdateSecurity Operation public virtual IAsyncResult BeginUpdateSecurity(UpdateSecurityRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSecurityRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSecurityResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateSecurity operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateSecurity. /// /// Returns a UpdateSecurityResult from Kafka. /// REST API Reference for UpdateSecurity Operation public virtual UpdateSecurityResponse EndUpdateSecurity(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateStorage ///

/// Updates cluster broker volume size (or) sets cluster storage mode to TIERED. ///

/// Container for the necessary parameters to execute the UpdateStorage service method. /// /// The response from the UpdateStorage service method, as returned by Kafka. /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// /// Returns information about an error. /// /// REST API Reference for UpdateStorage Operation public virtual UpdateStorageResponse UpdateStorage(UpdateStorageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateStorageRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateStorageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateStorage operation. ///

/// /// Container for the necessary parameters to execute the UpdateStorage operation on AmazonKafkaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateStorage /// operation. /// REST API Reference for UpdateStorage Operation public virtual IAsyncResult BeginUpdateStorage(UpdateStorageRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateStorageRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateStorageResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateStorage operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateStorage. /// /// Returns a UpdateStorageResult from Kafka. /// REST API Reference for UpdateStorage Operation public virtual UpdateStorageResponse EndUpdateStorage(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }