/* * 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 memorydb-2021-01-01.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.MemoryDB.Model; using Amazon.MemoryDB.Model.Internal.MarshallTransformations; using Amazon.MemoryDB.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.MemoryDB { ///

/// Implementation for accessing MemoryDB /// /// MemoryDB for Redis is a fully managed, Redis-compatible, in-memory database that delivers /// ultra-fast performance and Multi-AZ durability for modern applications built using /// microservices architectures. MemoryDB stores the entire database in-memory, enabling /// low latency and high throughput data access. It is compatible with Redis, a popular /// open source data store, enabling you to leverage Redis’ flexible and friendly data /// structures, APIs, and commands. ///

public partial class AmazonMemoryDBClient : AmazonServiceClient, IAmazonMemoryDB { private static IServiceMetadata serviceMetadata = new AmazonMemoryDBMetadata(); #if BCL45 || AWS_ASYNC_ENUMERABLES_API private IMemoryDBPaginatorFactory _paginators; ///

/// Paginators for the service ///

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

/// Constructs AmazonMemoryDBClient 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 AmazonMemoryDBClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonMemoryDBConfig()) { } ///


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

/// ///

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


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

/// ///

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

/// Constructs AmazonMemoryDBClient with AWS Credentials ///

/// AWS Credentials public AmazonMemoryDBClient(AWSCredentials credentials) : this(credentials, new AmazonMemoryDBConfig()) { } ///

/// Constructs AmazonMemoryDBClient with AWS Credentials ///

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

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

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

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

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

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

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

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

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

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

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

/// Constructs AmazonMemoryDBClient 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 AmazonMemoryDBClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonMemoryDBConfig{RegionEndpoint = region}) { } ///

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

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonMemoryDBClient Configuration Object public AmazonMemoryDBClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonMemoryDBConfig 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 AmazonMemoryDBEndpointResolver()); } ///

/// 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 BatchUpdateCluster ///

/// Apply the service update to a list of clusters supplied. For more information on service /// updates and applying them, see Applying /// the service updates. ///

/// Container for the necessary parameters to execute the BatchUpdateCluster service method. /// /// The response from the BatchUpdateCluster service method, as returned by MemoryDB. /// /// /// /// /// /// /// REST API Reference for BatchUpdateCluster Operation public virtual BatchUpdateClusterResponse BatchUpdateCluster(BatchUpdateClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = BatchUpdateClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchUpdateClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the BatchUpdateCluster operation on AmazonMemoryDBClient. /// 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 EndBatchUpdateCluster /// operation. /// REST API Reference for BatchUpdateCluster Operation public virtual IAsyncResult BeginBatchUpdateCluster(BatchUpdateClusterRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = BatchUpdateClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchUpdateClusterResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginBatchUpdateCluster. /// /// Returns a BatchUpdateClusterResult from MemoryDB. /// REST API Reference for BatchUpdateCluster Operation public virtual BatchUpdateClusterResponse EndBatchUpdateCluster(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CopySnapshot ///

/// Makes a copy of an existing snapshot. ///

/// Container for the necessary parameters to execute the CopySnapshot service method. /// /// The response from the CopySnapshot service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for CopySnapshot Operation public virtual CopySnapshotResponse CopySnapshot(CopySnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CopySnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CopySnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CopySnapshot operation on AmazonMemoryDBClient. /// 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 EndCopySnapshot /// operation. /// REST API Reference for CopySnapshot Operation public virtual IAsyncResult BeginCopySnapshot(CopySnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CopySnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CopySnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCopySnapshot. /// /// Returns a CopySnapshotResult from MemoryDB. /// REST API Reference for CopySnapshot Operation public virtual CopySnapshotResponse EndCopySnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateACL ///

/// Creates an Access Control List. For more information, see Authenticating /// users with Access Contol Lists (ACLs). ///

/// Container for the necessary parameters to execute the CreateACL service method. /// /// The response from the CreateACL service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for CreateACL Operation public virtual CreateACLResponse CreateACL(CreateACLRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateACLRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateACLResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateACL operation on AmazonMemoryDBClient. /// 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 EndCreateACL /// operation. /// REST API Reference for CreateACL Operation public virtual IAsyncResult BeginCreateACL(CreateACLRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateACLRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateACLResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateACL. /// /// Returns a CreateACLResult from MemoryDB. /// REST API Reference for CreateACL Operation public virtual CreateACLResponse EndCreateACL(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateCluster ///

/// Creates a cluster. All nodes in the cluster run the same protocol-compliant engine /// software. ///

/// Container for the necessary parameters to execute the CreateCluster service method. /// /// The response from the CreateCluster service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// 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 AmazonMemoryDBClient. /// 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 MemoryDB. /// REST API Reference for CreateCluster Operation public virtual CreateClusterResponse EndCreateCluster(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateParameterGroup ///

/// Creates a new MemoryDB parameter group. A parameter group is a collection of parameters /// and their values that are applied to all of the nodes in any cluster. For more information, /// see Configuring /// engine parameters using parameter groups. ///

/// Container for the necessary parameters to execute the CreateParameterGroup service method. /// /// The response from the CreateParameterGroup service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for CreateParameterGroup Operation public virtual CreateParameterGroupResponse CreateParameterGroup(CreateParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateParameterGroup operation on AmazonMemoryDBClient. /// 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 EndCreateParameterGroup /// operation. /// REST API Reference for CreateParameterGroup Operation public virtual IAsyncResult BeginCreateParameterGroup(CreateParameterGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateParameterGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateParameterGroup. /// /// Returns a CreateParameterGroupResult from MemoryDB. /// REST API Reference for CreateParameterGroup Operation public virtual CreateParameterGroupResponse EndCreateParameterGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateSnapshot ///

/// Creates a copy of an entire cluster at a specific moment in time. ///

/// Container for the necessary parameters to execute the CreateSnapshot service method. /// /// The response from the CreateSnapshot service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for CreateSnapshot Operation public virtual CreateSnapshotResponse CreateSnapshot(CreateSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateSnapshot operation on AmazonMemoryDBClient. /// 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 EndCreateSnapshot /// operation. /// REST API Reference for CreateSnapshot Operation public virtual IAsyncResult BeginCreateSnapshot(CreateSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateSnapshot. /// /// Returns a CreateSnapshotResult from MemoryDB. /// REST API Reference for CreateSnapshot Operation public virtual CreateSnapshotResponse EndCreateSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateSubnetGroup ///

/// Creates a subnet group. A subnet group is a collection of subnets (typically private) /// that you can designate for your clusters running in an Amazon Virtual Private Cloud /// (VPC) environment. When you create a cluster in an Amazon VPC, you must specify a /// subnet group. MemoryDB uses that subnet group to choose a subnet and IP addresses /// within that subnet to associate with your nodes. For more information, see Subnets /// and subnet groups. ///

/// Container for the necessary parameters to execute the CreateSubnetGroup service method. /// /// The response from the CreateSubnetGroup service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for CreateSubnetGroup Operation public virtual CreateSubnetGroupResponse CreateSubnetGroup(CreateSubnetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSubnetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateSubnetGroup operation on AmazonMemoryDBClient. /// 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 EndCreateSubnetGroup /// operation. /// REST API Reference for CreateSubnetGroup Operation public virtual IAsyncResult BeginCreateSubnetGroup(CreateSubnetGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSubnetGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateSubnetGroup. /// /// Returns a CreateSubnetGroupResult from MemoryDB. /// REST API Reference for CreateSubnetGroup Operation public virtual CreateSubnetGroupResponse EndCreateSubnetGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateUser ///

/// Creates a MemoryDB user. For more information, see Authenticating /// users with Access Contol Lists (ACLs). ///

/// Container for the necessary parameters to execute the CreateUser service method. /// /// The response from the CreateUser service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for CreateUser Operation public virtual CreateUserResponse CreateUser(CreateUserRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateUserRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateUserResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateUser operation on AmazonMemoryDBClient. /// 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 EndCreateUser /// operation. /// REST API Reference for CreateUser Operation public virtual IAsyncResult BeginCreateUser(CreateUserRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateUserRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateUserResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateUser. /// /// Returns a CreateUserResult from MemoryDB. /// REST API Reference for CreateUser Operation public virtual CreateUserResponse EndCreateUser(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteACL ///

/// Deletes an Access Control List. The ACL must first be disassociated from the cluster /// before it can be deleted. For more information, see Authenticating /// users with Access Contol Lists (ACLs). ///

/// Container for the necessary parameters to execute the DeleteACL service method. /// /// The response from the DeleteACL service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// REST API Reference for DeleteACL Operation public virtual DeleteACLResponse DeleteACL(DeleteACLRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteACLRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteACLResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteACL operation on AmazonMemoryDBClient. /// 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 EndDeleteACL /// operation. /// REST API Reference for DeleteACL Operation public virtual IAsyncResult BeginDeleteACL(DeleteACLRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteACLRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteACLResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteACL. /// /// Returns a DeleteACLResult from MemoryDB. /// REST API Reference for DeleteACL Operation public virtual DeleteACLResponse EndDeleteACL(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteCluster ///

/// Deletes a cluster. It also deletes all associated nodes and node endpoints ///

/// Container for the necessary parameters to execute the DeleteCluster service method. /// /// The response from the DeleteCluster service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// 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 AmazonMemoryDBClient. /// 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 MemoryDB. /// REST API Reference for DeleteCluster Operation public virtual DeleteClusterResponse EndDeleteCluster(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteParameterGroup ///

/// Deletes the specified parameter group. You cannot delete a parameter group if it is /// associated with any clusters. You cannot delete the default parameter groups in your /// account. ///

/// Container for the necessary parameters to execute the DeleteParameterGroup service method. /// /// The response from the DeleteParameterGroup service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for DeleteParameterGroup Operation public virtual DeleteParameterGroupResponse DeleteParameterGroup(DeleteParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteParameterGroup operation on AmazonMemoryDBClient. /// 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 EndDeleteParameterGroup /// operation. /// REST API Reference for DeleteParameterGroup Operation public virtual IAsyncResult BeginDeleteParameterGroup(DeleteParameterGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteParameterGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteParameterGroup. /// /// Returns a DeleteParameterGroupResult from MemoryDB. /// REST API Reference for DeleteParameterGroup Operation public virtual DeleteParameterGroupResponse EndDeleteParameterGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteSnapshot ///

/// Deletes an existing snapshot. When you receive a successful response from this operation, /// MemoryDB immediately begins deleting the snapshot; you cannot cancel or revert this /// operation. ///

/// Container for the necessary parameters to execute the DeleteSnapshot service method. /// /// The response from the DeleteSnapshot service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for DeleteSnapshot Operation public virtual DeleteSnapshotResponse DeleteSnapshot(DeleteSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteSnapshot operation on AmazonMemoryDBClient. /// 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 EndDeleteSnapshot /// operation. /// REST API Reference for DeleteSnapshot Operation public virtual IAsyncResult BeginDeleteSnapshot(DeleteSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteSnapshot. /// /// Returns a DeleteSnapshotResult from MemoryDB. /// REST API Reference for DeleteSnapshot Operation public virtual DeleteSnapshotResponse EndDeleteSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteSubnetGroup ///

/// Deletes a subnet group. You cannot delete a default subnet group or one that is associated /// with any clusters. ///

/// Container for the necessary parameters to execute the DeleteSubnetGroup service method. /// /// The response from the DeleteSubnetGroup service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// REST API Reference for DeleteSubnetGroup Operation public virtual DeleteSubnetGroupResponse DeleteSubnetGroup(DeleteSubnetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSubnetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteSubnetGroup operation on AmazonMemoryDBClient. /// 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 EndDeleteSubnetGroup /// operation. /// REST API Reference for DeleteSubnetGroup Operation public virtual IAsyncResult BeginDeleteSubnetGroup(DeleteSubnetGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSubnetGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteSubnetGroup. /// /// Returns a DeleteSubnetGroupResult from MemoryDB. /// REST API Reference for DeleteSubnetGroup Operation public virtual DeleteSubnetGroupResponse EndDeleteSubnetGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteUser ///

/// Deletes a user. The user will be removed from all ACLs and in turn removed from all /// clusters. ///

/// Container for the necessary parameters to execute the DeleteUser service method. /// /// The response from the DeleteUser service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// REST API Reference for DeleteUser Operation public virtual DeleteUserResponse DeleteUser(DeleteUserRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteUserRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteUserResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteUser operation on AmazonMemoryDBClient. /// 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 EndDeleteUser /// operation. /// REST API Reference for DeleteUser Operation public virtual IAsyncResult BeginDeleteUser(DeleteUserRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteUserRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteUserResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteUser. /// /// Returns a DeleteUserResult from MemoryDB. /// REST API Reference for DeleteUser Operation public virtual DeleteUserResponse EndDeleteUser(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeACLs ///

/// Returns a list of ACLs ///

/// Container for the necessary parameters to execute the DescribeACLs service method. /// /// The response from the DescribeACLs service method, as returned by MemoryDB. /// /// /// /// /// /// /// REST API Reference for DescribeACLs Operation public virtual DescribeACLsResponse DescribeACLs(DescribeACLsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeACLsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeACLsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DescribeACLs operation on AmazonMemoryDBClient. /// 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 EndDescribeACLs /// operation. /// REST API Reference for DescribeACLs Operation public virtual IAsyncResult BeginDescribeACLs(DescribeACLsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeACLsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeACLsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeACLs. /// /// Returns a DescribeACLsResult from MemoryDB. /// REST API Reference for DescribeACLs Operation public virtual DescribeACLsResponse EndDescribeACLs(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeClusters ///

/// Returns information about all provisioned clusters if no cluster identifier is specified, /// or about a specific cluster if a cluster name is supplied. ///

/// Container for the necessary parameters to execute the DescribeClusters service method. /// /// The response from the DescribeClusters service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for DescribeClusters Operation public virtual DescribeClustersResponse DescribeClusters(DescribeClustersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClustersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClustersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DescribeClusters operation on AmazonMemoryDBClient. /// 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 EndDescribeClusters /// operation. /// REST API Reference for DescribeClusters Operation public virtual IAsyncResult BeginDescribeClusters(DescribeClustersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClustersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClustersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeClusters. /// /// Returns a DescribeClustersResult from MemoryDB. /// REST API Reference for DescribeClusters Operation public virtual DescribeClustersResponse EndDescribeClusters(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeEngineVersions ///

/// Returns a list of the available Redis engine versions. ///

/// Container for the necessary parameters to execute the DescribeEngineVersions service method. /// /// The response from the DescribeEngineVersions service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// REST API Reference for DescribeEngineVersions Operation public virtual DescribeEngineVersionsResponse DescribeEngineVersions(DescribeEngineVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEngineVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEngineVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DescribeEngineVersions operation on AmazonMemoryDBClient. /// 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 EndDescribeEngineVersions /// operation. /// REST API Reference for DescribeEngineVersions Operation public virtual IAsyncResult BeginDescribeEngineVersions(DescribeEngineVersionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEngineVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEngineVersionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeEngineVersions. /// /// Returns a DescribeEngineVersionsResult from MemoryDB. /// REST API Reference for DescribeEngineVersions Operation public virtual DescribeEngineVersionsResponse EndDescribeEngineVersions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeEvents ///

/// Returns events related to clusters, security groups, and parameter groups. You can /// obtain events specific to a particular cluster, security group, or parameter group /// by providing the name as a parameter. By default, only the events occurring within /// the last hour are returned; however, you can retrieve up to 14 days' worth of events /// if necessary. ///

/// Container for the necessary parameters to execute the DescribeEvents service method. /// /// The response from the DescribeEvents service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// REST API Reference for DescribeEvents Operation public virtual DescribeEventsResponse DescribeEvents(DescribeEventsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DescribeEvents operation on AmazonMemoryDBClient. /// 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 EndDescribeEvents /// operation. /// REST API Reference for DescribeEvents Operation public virtual IAsyncResult BeginDescribeEvents(DescribeEventsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeEvents. /// /// Returns a DescribeEventsResult from MemoryDB. /// REST API Reference for DescribeEvents Operation public virtual DescribeEventsResponse EndDescribeEvents(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeParameterGroups ///

/// Returns a list of parameter group descriptions. If a parameter group name is specified, /// the list contains only the descriptions for that group. ///

/// Container for the necessary parameters to execute the DescribeParameterGroups service method. /// /// The response from the DescribeParameterGroups service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for DescribeParameterGroups Operation public virtual DescribeParameterGroupsResponse DescribeParameterGroups(DescribeParameterGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeParameterGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeParameterGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DescribeParameterGroups operation on AmazonMemoryDBClient. /// 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 EndDescribeParameterGroups /// operation. /// REST API Reference for DescribeParameterGroups Operation public virtual IAsyncResult BeginDescribeParameterGroups(DescribeParameterGroupsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeParameterGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeParameterGroupsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeParameterGroups. /// /// Returns a DescribeParameterGroupsResult from MemoryDB. /// REST API Reference for DescribeParameterGroups Operation public virtual DescribeParameterGroupsResponse EndDescribeParameterGroups(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeParameters ///

/// Returns the detailed parameter list for a particular parameter group. ///

/// Container for the necessary parameters to execute the DescribeParameters service method. /// /// The response from the DescribeParameters service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for DescribeParameters Operation public virtual DescribeParametersResponse DescribeParameters(DescribeParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DescribeParameters operation on AmazonMemoryDBClient. /// 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 EndDescribeParameters /// operation. /// REST API Reference for DescribeParameters Operation public virtual IAsyncResult BeginDescribeParameters(DescribeParametersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeParametersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeParameters. /// /// Returns a DescribeParametersResult from MemoryDB. /// REST API Reference for DescribeParameters Operation public virtual DescribeParametersResponse EndDescribeParameters(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeReservedNodes ///

/// Returns information about reserved nodes for this account, or about a specified reserved /// node. ///

/// Container for the necessary parameters to execute the DescribeReservedNodes service method. /// /// The response from the DescribeReservedNodes service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// The requested node does not exist. /// /// /// /// /// REST API Reference for DescribeReservedNodes Operation public virtual DescribeReservedNodesResponse DescribeReservedNodes(DescribeReservedNodesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedNodesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedNodesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DescribeReservedNodes operation on AmazonMemoryDBClient. /// 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 EndDescribeReservedNodes /// operation. /// REST API Reference for DescribeReservedNodes Operation public virtual IAsyncResult BeginDescribeReservedNodes(DescribeReservedNodesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedNodesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedNodesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeReservedNodes. /// /// Returns a DescribeReservedNodesResult from MemoryDB. /// REST API Reference for DescribeReservedNodes Operation public virtual DescribeReservedNodesResponse EndDescribeReservedNodes(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeReservedNodesOfferings ///

/// Lists available reserved node offerings. ///

/// Container for the necessary parameters to execute the DescribeReservedNodesOfferings service method. /// /// The response from the DescribeReservedNodesOfferings service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// The requested node offering does not exist. /// /// /// /// /// REST API Reference for DescribeReservedNodesOfferings Operation public virtual DescribeReservedNodesOfferingsResponse DescribeReservedNodesOfferings(DescribeReservedNodesOfferingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedNodesOfferingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedNodesOfferingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DescribeReservedNodesOfferings operation on AmazonMemoryDBClient. /// 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 EndDescribeReservedNodesOfferings /// operation. /// REST API Reference for DescribeReservedNodesOfferings Operation public virtual IAsyncResult BeginDescribeReservedNodesOfferings(DescribeReservedNodesOfferingsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedNodesOfferingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedNodesOfferingsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeReservedNodesOfferings. /// /// Returns a DescribeReservedNodesOfferingsResult from MemoryDB. /// REST API Reference for DescribeReservedNodesOfferings Operation public virtual DescribeReservedNodesOfferingsResponse EndDescribeReservedNodesOfferings(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeServiceUpdates ///

/// Returns details of the service updates ///

/// Container for the necessary parameters to execute the DescribeServiceUpdates service method. /// /// The response from the DescribeServiceUpdates service method, as returned by MemoryDB. /// /// /// /// /// /// /// REST API Reference for DescribeServiceUpdates Operation public virtual DescribeServiceUpdatesResponse DescribeServiceUpdates(DescribeServiceUpdatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeServiceUpdatesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeServiceUpdatesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DescribeServiceUpdates operation on AmazonMemoryDBClient. /// 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 EndDescribeServiceUpdates /// operation. /// REST API Reference for DescribeServiceUpdates Operation public virtual IAsyncResult BeginDescribeServiceUpdates(DescribeServiceUpdatesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeServiceUpdatesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeServiceUpdatesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeServiceUpdates. /// /// Returns a DescribeServiceUpdatesResult from MemoryDB. /// REST API Reference for DescribeServiceUpdates Operation public virtual DescribeServiceUpdatesResponse EndDescribeServiceUpdates(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeSnapshots ///

/// Returns information about cluster snapshots. By default, DescribeSnapshots lists all /// of your snapshots; it can optionally describe a single snapshot, or just the snapshots /// associated with a particular cluster. ///

/// Container for the necessary parameters to execute the DescribeSnapshots service method. /// /// The response from the DescribeSnapshots service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for DescribeSnapshots Operation public virtual DescribeSnapshotsResponse DescribeSnapshots(DescribeSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DescribeSnapshots operation on AmazonMemoryDBClient. /// 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 EndDescribeSnapshots /// operation. /// REST API Reference for DescribeSnapshots Operation public virtual IAsyncResult BeginDescribeSnapshots(DescribeSnapshotsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSnapshotsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeSnapshots. /// /// Returns a DescribeSnapshotsResult from MemoryDB. /// REST API Reference for DescribeSnapshots Operation public virtual DescribeSnapshotsResponse EndDescribeSnapshots(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeSubnetGroups ///

/// Returns a list of subnet group descriptions. If a subnet group name is specified, /// the list contains only the description of that group. ///

/// Container for the necessary parameters to execute the DescribeSubnetGroups service method. /// /// The response from the DescribeSubnetGroups service method, as returned by MemoryDB. /// /// /// /// /// /// /// REST API Reference for DescribeSubnetGroups Operation public virtual DescribeSubnetGroupsResponse DescribeSubnetGroups(DescribeSubnetGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSubnetGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSubnetGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DescribeSubnetGroups operation on AmazonMemoryDBClient. /// 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 EndDescribeSubnetGroups /// operation. /// REST API Reference for DescribeSubnetGroups Operation public virtual IAsyncResult BeginDescribeSubnetGroups(DescribeSubnetGroupsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSubnetGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSubnetGroupsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeSubnetGroups. /// /// Returns a DescribeSubnetGroupsResult from MemoryDB. /// REST API Reference for DescribeSubnetGroups Operation public virtual DescribeSubnetGroupsResponse EndDescribeSubnetGroups(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeUsers ///

/// Returns a list of users. ///

/// Container for the necessary parameters to execute the DescribeUsers service method. /// /// The response from the DescribeUsers service method, as returned by MemoryDB. /// /// /// /// /// /// /// REST API Reference for DescribeUsers Operation public virtual DescribeUsersResponse DescribeUsers(DescribeUsersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeUsersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeUsersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DescribeUsers operation on AmazonMemoryDBClient. /// 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 EndDescribeUsers /// operation. /// REST API Reference for DescribeUsers Operation public virtual IAsyncResult BeginDescribeUsers(DescribeUsersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeUsersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeUsersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeUsers. /// /// Returns a DescribeUsersResult from MemoryDB. /// REST API Reference for DescribeUsers Operation public virtual DescribeUsersResponse EndDescribeUsers(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region FailoverShard ///

/// Used to failover a shard. This API is designed for testing the behavior of your application /// in case of MemoryDB failover. It is not designed to be used as a production-level /// tool for initiating a failover to overcome a problem you may have with the cluster. /// Moreover, in certain conditions such as large scale operational events, Amazon may /// block this API. ///

/// Container for the necessary parameters to execute the FailoverShard service method. /// /// The response from the FailoverShard service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for FailoverShard Operation public virtual FailoverShardResponse FailoverShard(FailoverShardRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = FailoverShardRequestMarshaller.Instance; options.ResponseUnmarshaller = FailoverShardResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the FailoverShard operation on AmazonMemoryDBClient. /// 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 EndFailoverShard /// operation. /// REST API Reference for FailoverShard Operation public virtual IAsyncResult BeginFailoverShard(FailoverShardRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = FailoverShardRequestMarshaller.Instance; options.ResponseUnmarshaller = FailoverShardResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginFailoverShard. /// /// Returns a FailoverShardResult from MemoryDB. /// REST API Reference for FailoverShard Operation public virtual FailoverShardResponse EndFailoverShard(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListAllowedNodeTypeUpdates ///

/// Lists all available node types that you can scale to from your cluster's current node /// type. When you use the UpdateCluster operation to scale your cluster, the value of /// the NodeType parameter must be one of the node types returned by this operation. ///

/// Container for the necessary parameters to execute the ListAllowedNodeTypeUpdates service method. /// /// The response from the ListAllowedNodeTypeUpdates service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for ListAllowedNodeTypeUpdates Operation public virtual ListAllowedNodeTypeUpdatesResponse ListAllowedNodeTypeUpdates(ListAllowedNodeTypeUpdatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListAllowedNodeTypeUpdatesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAllowedNodeTypeUpdatesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListAllowedNodeTypeUpdates operation on AmazonMemoryDBClient. /// 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 EndListAllowedNodeTypeUpdates /// operation. /// REST API Reference for ListAllowedNodeTypeUpdates Operation public virtual IAsyncResult BeginListAllowedNodeTypeUpdates(ListAllowedNodeTypeUpdatesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListAllowedNodeTypeUpdatesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAllowedNodeTypeUpdatesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListAllowedNodeTypeUpdates. /// /// Returns a ListAllowedNodeTypeUpdatesResult from MemoryDB. /// REST API Reference for ListAllowedNodeTypeUpdates Operation public virtual ListAllowedNodeTypeUpdatesResponse EndListAllowedNodeTypeUpdates(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTags ///

/// Lists all tags currently on a named resource. A tag is a key-value pair where the /// key and value are case-sensitive. You can use tags to categorize and track your MemoryDB /// resources. For more information, see Tagging /// your MemoryDB resources ///

/// Container for the necessary parameters to execute the ListTags service method. /// /// The response from the ListTags service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for ListTags Operation public virtual ListTagsResponse ListTags(ListTagsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListTags operation on AmazonMemoryDBClient. /// 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 EndListTags /// operation. /// REST API Reference for ListTags Operation public virtual IAsyncResult BeginListTags(ListTagsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListTags. /// /// Returns a ListTagsResult from MemoryDB. /// REST API Reference for ListTags Operation public virtual ListTagsResponse EndListTags(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region PurchaseReservedNodesOffering ///

/// Allows you to purchase a reserved node offering. Reserved nodes are not eligible for /// cancellation and are non-refundable. ///

/// Container for the necessary parameters to execute the PurchaseReservedNodesOffering service method. /// /// The response from the PurchaseReservedNodesOffering service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// You already have a reservation with the given identifier. /// /// /// The request cannot be processed because it would exceed the user's node quota. /// /// /// The requested node offering does not exist. /// /// /// /// /// /// /// /// REST API Reference for PurchaseReservedNodesOffering Operation public virtual PurchaseReservedNodesOfferingResponse PurchaseReservedNodesOffering(PurchaseReservedNodesOfferingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PurchaseReservedNodesOfferingRequestMarshaller.Instance; options.ResponseUnmarshaller = PurchaseReservedNodesOfferingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the PurchaseReservedNodesOffering operation on AmazonMemoryDBClient. /// 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 EndPurchaseReservedNodesOffering /// operation. /// REST API Reference for PurchaseReservedNodesOffering Operation public virtual IAsyncResult BeginPurchaseReservedNodesOffering(PurchaseReservedNodesOfferingRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = PurchaseReservedNodesOfferingRequestMarshaller.Instance; options.ResponseUnmarshaller = PurchaseReservedNodesOfferingResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginPurchaseReservedNodesOffering. /// /// Returns a PurchaseReservedNodesOfferingResult from MemoryDB. /// REST API Reference for PurchaseReservedNodesOffering Operation public virtual PurchaseReservedNodesOfferingResponse EndPurchaseReservedNodesOffering(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ResetParameterGroup ///

/// Modifies the parameters of a parameter group to the engine or system default value. /// You can reset specific parameters by submitting a list of parameter names. To reset /// the entire parameter group, specify the AllParameters and ParameterGroupName parameters. ///

/// Container for the necessary parameters to execute the ResetParameterGroup service method. /// /// The response from the ResetParameterGroup service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for ResetParameterGroup Operation public virtual ResetParameterGroupResponse ResetParameterGroup(ResetParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ResetParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ResetParameterGroup operation on AmazonMemoryDBClient. /// 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 EndResetParameterGroup /// operation. /// REST API Reference for ResetParameterGroup Operation public virtual IAsyncResult BeginResetParameterGroup(ResetParameterGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ResetParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetParameterGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginResetParameterGroup. /// /// Returns a ResetParameterGroupResult from MemoryDB. /// REST API Reference for ResetParameterGroup Operation public virtual ResetParameterGroupResponse EndResetParameterGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TagResource ///

/// A tag is a key-value pair where the key and value are case-sensitive. You can use /// tags to categorize and track all your MemoryDB resources. When you add or remove tags /// on clusters, those actions will be replicated to all nodes in the cluster. For more /// information, see Resource-level /// permissions. /// /// /// /// For example, you can use cost-allocation tags to your MemoryDB resources, Amazon generates /// a cost allocation report as a comma-separated value (CSV) file with your usage and /// costs aggregated by your tags. You can apply tags that represent business categories /// (such as cost centers, application names, or owners) to organize your costs across /// multiple services. For more information, see Using /// Cost Allocation Tags. /// ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// 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 AmazonMemoryDBClient. /// 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 MemoryDB. /// REST API Reference for TagResource Operation public virtual TagResourceResponse EndTagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UntagResource ///

/// Use this operation to remove tags on a resource ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// 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 AmazonMemoryDBClient. /// 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 MemoryDB. /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse EndUntagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateACL ///

/// Changes the list of users that belong to the Access Control List. ///

/// Container for the necessary parameters to execute the UpdateACL service method. /// /// The response from the UpdateACL service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for UpdateACL Operation public virtual UpdateACLResponse UpdateACL(UpdateACLRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateACLRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateACLResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateACL operation on AmazonMemoryDBClient. /// 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 EndUpdateACL /// operation. /// REST API Reference for UpdateACL Operation public virtual IAsyncResult BeginUpdateACL(UpdateACLRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateACLRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateACLResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateACL. /// /// Returns a UpdateACLResult from MemoryDB. /// REST API Reference for UpdateACL Operation public virtual UpdateACLResponse EndUpdateACL(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateCluster ///

/// Modifies the settings for a cluster. You can use this operation to change one or more /// cluster configuration settings by specifying the settings and the new values. ///

/// Container for the necessary parameters to execute the UpdateCluster service method. /// /// The response from the UpdateCluster service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for UpdateCluster Operation public virtual UpdateClusterResponse UpdateCluster(UpdateClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateCluster operation on AmazonMemoryDBClient. /// 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 EndUpdateCluster /// operation. /// REST API Reference for UpdateCluster Operation public virtual IAsyncResult BeginUpdateCluster(UpdateClusterRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateClusterResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateCluster. /// /// Returns a UpdateClusterResult from MemoryDB. /// REST API Reference for UpdateCluster Operation public virtual UpdateClusterResponse EndUpdateCluster(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateParameterGroup ///

/// Updates the parameters of a parameter group. You can modify up to 20 parameters in /// a single request by submitting a list parameter name and value pairs. ///

/// Container for the necessary parameters to execute the UpdateParameterGroup service method. /// /// The response from the UpdateParameterGroup service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for UpdateParameterGroup Operation public virtual UpdateParameterGroupResponse UpdateParameterGroup(UpdateParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateParameterGroup operation on AmazonMemoryDBClient. /// 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 EndUpdateParameterGroup /// operation. /// REST API Reference for UpdateParameterGroup Operation public virtual IAsyncResult BeginUpdateParameterGroup(UpdateParameterGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateParameterGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateParameterGroup. /// /// Returns a UpdateParameterGroupResult from MemoryDB. /// REST API Reference for UpdateParameterGroup Operation public virtual UpdateParameterGroupResponse EndUpdateParameterGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateSubnetGroup ///

/// Updates a subnet group. For more information, see Updating /// a subnet group ///

/// Container for the necessary parameters to execute the UpdateSubnetGroup service method. /// /// The response from the UpdateSubnetGroup service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for UpdateSubnetGroup Operation public virtual UpdateSubnetGroupResponse UpdateSubnetGroup(UpdateSubnetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSubnetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateSubnetGroup operation on AmazonMemoryDBClient. /// 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 EndUpdateSubnetGroup /// operation. /// REST API Reference for UpdateSubnetGroup Operation public virtual IAsyncResult BeginUpdateSubnetGroup(UpdateSubnetGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSubnetGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateSubnetGroup. /// /// Returns a UpdateSubnetGroupResult from MemoryDB. /// REST API Reference for UpdateSubnetGroup Operation public virtual UpdateSubnetGroupResponse EndUpdateSubnetGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateUser ///

/// Changes user password(s) and/or access string. ///

/// Container for the necessary parameters to execute the UpdateUser service method. /// /// The response from the UpdateUser service method, as returned by MemoryDB. /// /// /// /// /// /// /// /// /// /// /// /// /// REST API Reference for UpdateUser Operation public virtual UpdateUserResponse UpdateUser(UpdateUserRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateUserRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateUserResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateUser operation on AmazonMemoryDBClient. /// 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 EndUpdateUser /// operation. /// REST API Reference for UpdateUser Operation public virtual IAsyncResult BeginUpdateUser(UpdateUserRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateUserRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateUserResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateUser. /// /// Returns a UpdateUserResult from MemoryDB. /// REST API Reference for UpdateUser Operation public virtual UpdateUserResponse EndUpdateUser(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }