/* * 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 rds-2014-10-31.normal.json service model. */ using System; using System.Runtime.ExceptionServices; using System.Threading; using System.Threading.Tasks; using System.Collections.Generic; using System.Net; using Amazon.RDS.Model; using Amazon.RDS.Model.Internal.MarshallTransformations; using Amazon.RDS.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.RDS { ///

/// Implementation for accessing RDS /// /// Amazon Relational Database Service /// /// Amazon Relational Database Service (Amazon RDS) is a web service that makes it easier /// to set up, operate, and scale a relational database in the cloud. It provides cost-efficient, /// resizeable capacity for an industry-standard relational database and manages common /// database administration tasks, freeing up developers to focus on what makes their /// applications and businesses unique. /// /// /// /// Amazon RDS gives you access to the capabilities of a MySQL, MariaDB, PostgreSQL, Microsoft /// SQL Server, Oracle, or Amazon Aurora database server. These capabilities mean that /// the code, applications, and tools you already use today with your existing databases /// work with Amazon RDS without modification. Amazon RDS automatically backs up your /// database and maintains the database software that powers your DB instance. Amazon /// RDS is flexible: you can scale your DB instance's compute resources and storage capacity /// to meet your application's demand. As with all Amazon Web Services, there are no up-front /// investments, and you pay only for the resources you use. /// /// /// /// This interface reference for Amazon RDS contains documentation for a programming or /// command line interface you can use to manage Amazon RDS. Amazon RDS is asynchronous, /// which means that some interfaces might require techniques such as polling or callback /// functions to determine when a command has been applied. In this reference, the parameter /// descriptions indicate whether a command is applied immediately, on the next instance /// reboot, or during the maintenance window. The reference structure is as follows, and /// we list following some related topics from the user guide. /// /// /// /// Amazon RDS API Reference /// ///

/// /// For the alphabetical list of API actions, see API /// Actions. /// ///
/// /// For the alphabetical list of data types, see Data /// Types. /// ///
/// /// For a list of common query parameters, see Common /// Parameters. /// ///
/// /// For descriptions of the error codes, see Common /// Errors. /// ///

/// /// Amazon RDS User Guide /// ///

/// /// For a summary of the Amazon RDS interfaces, see Available /// RDS Interfaces. /// ///
/// /// For more information about how to use the Query API, see Using /// the Query API. /// ///

///

public partial class AmazonRDSClient : AmazonServiceClient, IAmazonRDS { private static IServiceMetadata serviceMetadata = new AmazonRDSMetadata(); #region Constructors ///

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


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

/// ///

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


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

/// ///

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

/// Constructs AmazonRDSClient with AWS Credentials ///

/// AWS Credentials public AmazonRDSClient(AWSCredentials credentials) : this(credentials, new AmazonRDSConfig()) { } ///

/// Constructs AmazonRDSClient with AWS Credentials ///

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

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

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

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

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

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

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

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

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

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

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

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

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

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonRDSClient Configuration Object public AmazonRDSClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonRDSConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig) { } #endregion #if AWS_ASYNC_ENUMERABLES_API private IRDSPaginatorFactory _paginators; ///

/// Paginators for the service ///

public IRDSPaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new RDSPaginatorFactory(this); } return this._paginators; } } #endif #region Overrides ///

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

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

/// Customizes the runtime pipeline. ///

/// Runtime pipeline for the current client. protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline) { pipeline.AddHandlerBefore(new Amazon.RDS.Internal.PreSignedUrlRequestHandler(this.Credentials)); pipeline.RemoveHandler(); pipeline.AddHandlerAfter(new AmazonRDSEndpointResolver()); } ///

/// 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 AddRoleToDBCluster internal virtual AddRoleToDBClusterResponse AddRoleToDBCluster(AddRoleToDBClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddRoleToDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = AddRoleToDBClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Associates an Identity and Access Management (IAM) role with a DB cluster. ///

/// Container for the necessary parameters to execute the AddRoleToDBCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AddRoleToDBCluster service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// The specified IAM role Amazon Resource Name (ARN) is already associated with the specified /// DB cluster. /// /// /// You have exceeded the maximum number of IAM roles that can be associated with the /// specified DB cluster. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// REST API Reference for AddRoleToDBCluster Operation public virtual Task AddRoleToDBClusterAsync(AddRoleToDBClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AddRoleToDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = AddRoleToDBClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AddRoleToDBInstance internal virtual AddRoleToDBInstanceResponse AddRoleToDBInstance(AddRoleToDBInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddRoleToDBInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddRoleToDBInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Associates an Amazon Web Services Identity and Access Management (IAM) role with a /// DB instance. /// /// /// /// To add a role to a DB instance, the status of the DB instance must be available. /// /// /// /// This command doesn't apply to RDS Custom. /// ///

/// Container for the necessary parameters to execute the AddRoleToDBInstance service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AddRoleToDBInstance service method, as returned by RDS. /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// The specified RoleArn or FeatureName value is already associated /// with the DB instance. /// /// /// You can't associate any more Amazon Web Services Identity and Access Management (IAM) /// roles with the DB instance because the quota has been reached. /// /// /// The DB instance isn't in a valid state. /// /// REST API Reference for AddRoleToDBInstance Operation public virtual Task AddRoleToDBInstanceAsync(AddRoleToDBInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AddRoleToDBInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddRoleToDBInstanceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AddSourceIdentifierToSubscription internal virtual AddSourceIdentifierToSubscriptionResponse AddSourceIdentifierToSubscription(AddSourceIdentifierToSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddSourceIdentifierToSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = AddSourceIdentifierToSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Adds a source identifier to an existing RDS event notification subscription. ///

/// Container for the necessary parameters to execute the AddSourceIdentifierToSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AddSourceIdentifierToSubscription service method, as returned by RDS. /// /// The requested source could not be found. /// /// /// The subscription name does not exist. /// /// REST API Reference for AddSourceIdentifierToSubscription Operation public virtual Task AddSourceIdentifierToSubscriptionAsync(AddSourceIdentifierToSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AddSourceIdentifierToSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = AddSourceIdentifierToSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AddTagsToResource internal virtual AddTagsToResourceResponse AddTagsToResource(AddTagsToResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddTagsToResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddTagsToResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Adds metadata tags to an Amazon RDS resource. These tags can also be used with cost /// allocation reporting to track cost associated with Amazon RDS resources, or used in /// a Condition statement in an IAM policy for Amazon RDS. /// /// /// /// For an overview on tagging Amazon RDS resources, see Tagging /// Amazon RDS Resources. /// ///

/// Container for the necessary parameters to execute the AddTagsToResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AddTagsToResource service method, as returned by RDS. /// /// BlueGreenDeploymentIdentifier doesn't refer to an existing blue/green /// deployment. /// /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The specified target group isn't available for a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// DBSnapshotIdentifier doesn't refer to an existing DB snapshot. /// /// REST API Reference for AddTagsToResource Operation public virtual Task AddTagsToResourceAsync(AddTagsToResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AddTagsToResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddTagsToResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ApplyPendingMaintenanceAction internal virtual ApplyPendingMaintenanceActionResponse ApplyPendingMaintenanceAction(ApplyPendingMaintenanceActionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ApplyPendingMaintenanceActionRequestMarshaller.Instance; options.ResponseUnmarshaller = ApplyPendingMaintenanceActionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Applies a pending maintenance action to a resource (for example, to a DB instance). ///

/// Container for the necessary parameters to execute the ApplyPendingMaintenanceAction service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ApplyPendingMaintenanceAction service method, as returned by RDS. /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB instance isn't in a valid state. /// /// /// The specified resource ID was not found. /// /// REST API Reference for ApplyPendingMaintenanceAction Operation public virtual Task ApplyPendingMaintenanceActionAsync(ApplyPendingMaintenanceActionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ApplyPendingMaintenanceActionRequestMarshaller.Instance; options.ResponseUnmarshaller = ApplyPendingMaintenanceActionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AuthorizeDBSecurityGroupIngress internal virtual AuthorizeDBSecurityGroupIngressResponse AuthorizeDBSecurityGroupIngress(AuthorizeDBSecurityGroupIngressRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeDBSecurityGroupIngressRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeDBSecurityGroupIngressResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Enables ingress to a DBSecurityGroup using one of two forms of authorization. First, /// EC2 or VPC security groups can be added to the DBSecurityGroup if the application /// using the database is running on EC2 or VPC instances. Second, IP ranges are available /// if the application accessing your database is running on the internet. Required parameters /// for this API are one of CIDR range, EC2SecurityGroupId for VPC, or (EC2SecurityGroupOwnerId /// and either EC2SecurityGroupName or EC2SecurityGroupId for non-VPC). /// /// /// /// You can't authorize ingress from an EC2 security group in one Amazon Web Services /// Region to an Amazon RDS DB instance in another. You can't authorize ingress from a /// VPC security group in one VPC to an Amazon RDS DB instance in another. /// /// /// /// For an overview of CIDR ranges, go to the Wikipedia /// Tutorial. /// /// /// /// EC2-Classic was retired on August 15, 2022. If you haven't migrated from EC2-Classic /// to a VPC, we recommend that you migrate as soon as possible. For more information, /// see Migrate /// from EC2-Classic to a VPC in the Amazon EC2 User Guide, the blog EC2-Classic /// Networking is Retiring – Here’s How to Prepare, and Moving /// a DB instance not in a VPC into a VPC in the Amazon RDS User Guide. /// /// ///

/// Container for the necessary parameters to execute the AuthorizeDBSecurityGroupIngress service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AuthorizeDBSecurityGroupIngress service method, as returned by RDS. /// /// The specified CIDR IP range or Amazon EC2 security group is already authorized for /// the specified DB security group. /// /// /// The DB security group authorization quota has been reached. /// /// /// DBSecurityGroupName doesn't refer to an existing DB security group. /// /// /// The state of the DB security group doesn't allow deletion. /// /// REST API Reference for AuthorizeDBSecurityGroupIngress Operation public virtual Task AuthorizeDBSecurityGroupIngressAsync(AuthorizeDBSecurityGroupIngressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeDBSecurityGroupIngressRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeDBSecurityGroupIngressResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region BacktrackDBCluster internal virtual BacktrackDBClusterResponse BacktrackDBCluster(BacktrackDBClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = BacktrackDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = BacktrackDBClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Backtracks a DB cluster to a specific time, without creating a new DB cluster. /// /// /// /// For more information on backtracking, see /// Backtracking an Aurora DB Cluster in the Amazon Aurora User Guide. /// /// /// /// This action applies only to Aurora MySQL DB clusters. /// /// ///

/// Container for the necessary parameters to execute the BacktrackDBCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the BacktrackDBCluster service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// REST API Reference for BacktrackDBCluster Operation public virtual Task BacktrackDBClusterAsync(BacktrackDBClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = BacktrackDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = BacktrackDBClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CancelExportTask internal virtual CancelExportTaskResponse CancelExportTask(CancelExportTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelExportTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelExportTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Cancels an export task in progress that is exporting a snapshot or cluster to Amazon /// S3. Any data that has already been written to the S3 bucket isn't removed. ///

/// Container for the necessary parameters to execute the CancelExportTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelExportTask service method, as returned by RDS. /// /// The export task doesn't exist. /// /// /// You can't cancel an export task that has completed. /// /// REST API Reference for CancelExportTask Operation public virtual Task CancelExportTaskAsync(CancelExportTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelExportTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelExportTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CopyDBClusterParameterGroup internal virtual CopyDBClusterParameterGroupResponse CopyDBClusterParameterGroup(CopyDBClusterParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CopyDBClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyDBClusterParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Copies the specified DB cluster parameter group. ///

/// Container for the necessary parameters to execute the CopyDBClusterParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CopyDBClusterParameterGroup service method, as returned by RDS. /// /// A DB parameter group with the same name exists. /// /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// The request would result in the user exceeding the allowed number of DB parameter /// groups. /// /// REST API Reference for CopyDBClusterParameterGroup Operation public virtual Task CopyDBClusterParameterGroupAsync(CopyDBClusterParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CopyDBClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyDBClusterParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CopyDBClusterSnapshot internal virtual CopyDBClusterSnapshotResponse CopyDBClusterSnapshot(CopyDBClusterSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CopyDBClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyDBClusterSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Copies a snapshot of a DB cluster. /// /// /// /// To copy a DB cluster snapshot from a shared manual DB cluster snapshot, SourceDBClusterSnapshotIdentifier /// must be the Amazon Resource Name (ARN) of the shared DB cluster snapshot. /// /// /// /// You can copy an encrypted DB cluster snapshot from another Amazon Web Services Region. /// In that case, the Amazon Web Services Region where you call the CopyDBClusterSnapshot /// operation is the destination Amazon Web Services Region for the encrypted DB cluster /// snapshot to be copied to. To copy an encrypted DB cluster snapshot from another Amazon /// Web Services Region, you must provide the following values: /// ///

/// /// KmsKeyId - The Amazon Web Services Key Management System (Amazon Web /// Services KMS) key identifier for the key to use to encrypt the copy of the DB cluster /// snapshot in the destination Amazon Web Services Region. /// ///
/// /// TargetDBClusterSnapshotIdentifier - The identifier for the new copy /// of the DB cluster snapshot in the destination Amazon Web Services Region. /// ///
/// /// SourceDBClusterSnapshotIdentifier - The DB cluster snapshot identifier /// for the encrypted DB cluster snapshot to be copied. This identifier must be in the /// ARN format for the source Amazon Web Services Region and is the same value as the /// SourceDBClusterSnapshotIdentifier in the presigned URL. /// ///

/// /// To cancel the copy operation once it is in progress, delete the target DB cluster /// snapshot identified by TargetDBClusterSnapshotIdentifier while that DB /// cluster snapshot is in "copying" status. /// /// /// /// For more information on copying encrypted Amazon Aurora DB cluster snapshots from /// one Amazon Web Services Region to another, see /// Copying a Snapshot in the Amazon Aurora User Guide. /// /// /// /// For more information on Amazon Aurora DB clusters, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the CopyDBClusterSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CopyDBClusterSnapshot service method, as returned by RDS. /// /// The user already has a DB cluster snapshot with the given identifier. /// /// /// DBClusterSnapshotIdentifier doesn't refer to an existing DB cluster /// snapshot. /// /// /// The supplied value isn't a valid DB cluster snapshot state. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// An error occurred accessing an Amazon Web Services KMS key. /// /// /// The request would result in the user exceeding the allowed number of DB snapshots. /// /// REST API Reference for CopyDBClusterSnapshot Operation public virtual Task CopyDBClusterSnapshotAsync(CopyDBClusterSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CopyDBClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyDBClusterSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CopyDBParameterGroup internal virtual CopyDBParameterGroupResponse CopyDBParameterGroup(CopyDBParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CopyDBParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyDBParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Copies the specified DB parameter group. ///

/// Container for the necessary parameters to execute the CopyDBParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CopyDBParameterGroup service method, as returned by RDS. /// /// A DB parameter group with the same name exists. /// /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// The request would result in the user exceeding the allowed number of DB parameter /// groups. /// /// REST API Reference for CopyDBParameterGroup Operation public virtual Task CopyDBParameterGroupAsync(CopyDBParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CopyDBParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyDBParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CopyDBSnapshot internal virtual CopyDBSnapshotResponse CopyDBSnapshot(CopyDBSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CopyDBSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyDBSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Copies the specified DB snapshot. The source DB snapshot must be in the available /// state. /// /// /// /// You can copy a snapshot from one Amazon Web Services Region to another. In that case, /// the Amazon Web Services Region where you call the CopyDBSnapshot operation /// is the destination Amazon Web Services Region for the DB snapshot copy. /// /// /// /// This command doesn't apply to RDS Custom. /// /// /// /// For more information about copying snapshots, see Copying /// a DB Snapshot in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the CopyDBSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CopyDBSnapshot service method, as returned by RDS. /// /// CustomAvailabilityZoneId doesn't refer to an existing custom Availability /// Zone identifier. /// /// /// DBSnapshotIdentifier is already used by an existing snapshot. /// /// /// DBSnapshotIdentifier doesn't refer to an existing DB snapshot. /// /// /// The state of the DB snapshot doesn't allow deletion. /// /// /// An error occurred accessing an Amazon Web Services KMS key. /// /// /// The request would result in the user exceeding the allowed number of DB snapshots. /// /// REST API Reference for CopyDBSnapshot Operation public virtual Task CopyDBSnapshotAsync(CopyDBSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CopyDBSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyDBSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CopyOptionGroup internal virtual CopyOptionGroupResponse CopyOptionGroup(CopyOptionGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CopyOptionGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyOptionGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Copies the specified option group. ///

/// Container for the necessary parameters to execute the CopyOptionGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CopyOptionGroup service method, as returned by RDS. /// /// The option group you are trying to create already exists. /// /// /// The specified option group could not be found. /// /// /// The quota of 20 option groups was exceeded for this Amazon Web Services account. /// /// REST API Reference for CopyOptionGroup Operation public virtual Task CopyOptionGroupAsync(CopyOptionGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CopyOptionGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyOptionGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateBlueGreenDeployment internal virtual CreateBlueGreenDeploymentResponse CreateBlueGreenDeployment(CreateBlueGreenDeploymentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateBlueGreenDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateBlueGreenDeploymentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a blue/green deployment. /// /// /// /// A blue/green deployment creates a staging environment that copies the production environment. /// In a blue/green deployment, the blue environment is the current production environment. /// The green environment is the staging environment. The staging environment stays in /// sync with the current production environment using logical replication. /// /// /// /// You can make changes to the databases in the green environment without affecting production /// workloads. For example, you can upgrade the major or minor DB engine version, change /// database parameters, or make schema changes in the staging environment. You can thoroughly /// test changes in the green environment. When ready, you can switch over the environments /// to promote the green environment to be the new production environment. The switchover /// typically takes under a minute. /// /// /// /// For more information, see Using /// Amazon RDS Blue/Green Deployments for database updates in the Amazon RDS User /// Guide and /// Using Amazon RDS Blue/Green Deployments for database updates in the Amazon /// Aurora User Guide. /// ///

/// Container for the necessary parameters to execute the CreateBlueGreenDeployment service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateBlueGreenDeployment service method, as returned by RDS. /// /// A blue/green deployment with the specified name already exists. /// /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// DBClusterParameterGroupName doesn't refer to an existing DB cluster /// parameter group. /// /// /// The user attempted to create a new DB cluster and the user has already reached the /// maximum allowed DB cluster quota. /// /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// The request would result in the user exceeding the allowed number of DB instances. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB instance isn't in a valid state. /// /// /// The source DB cluster isn't supported for a blue/green deployment. /// /// /// The source DB instance isn't supported for a blue/green deployment. /// /// REST API Reference for CreateBlueGreenDeployment Operation public virtual Task CreateBlueGreenDeploymentAsync(CreateBlueGreenDeploymentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateBlueGreenDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateBlueGreenDeploymentResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateCustomDBEngineVersion internal virtual CreateCustomDBEngineVersionResponse CreateCustomDBEngineVersion(CreateCustomDBEngineVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCustomDBEngineVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCustomDBEngineVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a custom DB engine version (CEV). ///

/// Container for the necessary parameters to execute the CreateCustomDBEngineVersion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateCustomDBEngineVersion service method, as returned by RDS. /// /// An error occurred while trying to create the CEV. /// /// /// A CEV with the specified name already exists. /// /// /// You have exceeded your CEV quota. /// /// /// The AMI configuration prerequisite has not been met. /// /// /// An error occurred accessing an Amazon Web Services KMS key. /// /// REST API Reference for CreateCustomDBEngineVersion Operation public virtual Task CreateCustomDBEngineVersionAsync(CreateCustomDBEngineVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCustomDBEngineVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCustomDBEngineVersionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDBCluster internal virtual CreateDBClusterResponse CreateDBCluster(CreateDBClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new Amazon Aurora DB cluster or Multi-AZ DB cluster. /// /// /// /// If you create an Aurora DB cluster, the request creates an empty cluster. You must /// explicitly create the writer instance for your DB cluster using the CreateDBInstance /// operation. If you create a Multi-AZ DB cluster, the request creates a writer and two /// reader DB instances for you, each in a different Availability Zone. /// /// /// /// You can use the ReplicationSourceIdentifier parameter to create an Amazon /// Aurora DB cluster as a read replica of another DB cluster or Amazon RDS for MySQL /// or PostgreSQL DB instance. For more information about Amazon Aurora, see What /// is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// You can also use the ReplicationSourceIdentifier parameter to create /// a Multi-AZ DB cluster read replica with an RDS for MySQL or PostgreSQL DB instance /// as the source. For more information about Multi-AZ DB clusters, see Multi-AZ /// DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the CreateDBCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDBCluster service method, as returned by RDS. /// /// The user already has a DB cluster with the given identifier. /// /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// DBClusterParameterGroupName doesn't refer to an existing DB cluster /// parameter group. /// /// /// The user attempted to create a new DB cluster and the user has already reached the /// maximum allowed DB cluster quota. /// /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// Subnets in the DB subnet group should cover at least two Availability Zones unless /// there is only one Availability Zone. /// /// /// DBSubnetGroupName doesn't refer to an existing DB subnet group. /// /// /// Domain doesn't refer to an existing Active Directory domain. /// /// /// The GlobalClusterIdentifier doesn't refer to an existing global database /// cluster. /// /// /// There is insufficient storage available for the current action. You might be able /// to resolve this error by updating your subnet group to use different Availability /// Zones that have more storage available. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB instance isn't in a valid state. /// /// /// The DB subnet group cannot be deleted because it's in use. /// /// /// The global cluster is in an invalid state and can't perform the requested operation. /// /// /// The requested subnet is invalid, or multiple subnets were requested that are not all /// in a common VPC. /// /// /// The DB subnet group doesn't cover all Availability Zones after it's created because /// of users' change. /// /// /// An error occurred accessing an Amazon Web Services KMS key. /// /// /// The request would result in the user exceeding the allowed amount of storage available /// across all DB instances. /// /// REST API Reference for CreateDBCluster Operation public virtual Task CreateDBClusterAsync(CreateDBClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDBClusterEndpoint internal virtual CreateDBClusterEndpointResponse CreateDBClusterEndpoint(CreateDBClusterEndpointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBClusterEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBClusterEndpointResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new custom endpoint and associates it with an Amazon Aurora DB cluster. /// /// /// /// This action applies only to Aurora DB clusters. /// /// ///

/// Container for the necessary parameters to execute the CreateDBClusterEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDBClusterEndpoint service method, as returned by RDS. /// /// The specified custom endpoint can't be created because it already exists. /// /// /// The cluster already has the maximum number of custom endpoints. /// /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB instance isn't in a valid state. /// /// REST API Reference for CreateDBClusterEndpoint Operation public virtual Task CreateDBClusterEndpointAsync(CreateDBClusterEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBClusterEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBClusterEndpointResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDBClusterParameterGroup internal virtual CreateDBClusterParameterGroupResponse CreateDBClusterParameterGroup(CreateDBClusterParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBClusterParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new DB cluster parameter group. /// /// /// /// Parameters in a DB cluster parameter group apply to all of the instances in a DB cluster. /// /// /// /// A DB cluster parameter group is initially created with the default parameters for /// the database engine used by instances in the DB cluster. To provide custom values /// for any of the parameters, you must modify the group after creating it using ModifyDBClusterParameterGroup. /// Once you've created a DB cluster parameter group, you need to associate it with your /// DB cluster using ModifyDBCluster. /// /// /// /// When you associate a new DB cluster parameter group with a running Aurora DB cluster, /// reboot the DB instances in the DB cluster without failover for the new DB cluster /// parameter group and associated settings to take effect. /// /// /// /// When you associate a new DB cluster parameter group with a running Multi-AZ DB cluster, /// reboot the DB cluster without failover for the new DB cluster parameter group and /// associated settings to take effect. /// /// /// /// After you create a DB cluster parameter group, you should wait at least 5 minutes /// before creating your first DB cluster that uses that DB cluster parameter group as /// the default parameter group. This allows Amazon RDS to fully complete the create action /// before the DB cluster parameter group is used as the default for a new DB cluster. /// This is especially important for parameters that are critical when creating the default /// database for a DB cluster, such as the character set for the default database defined /// by the character_set_database parameter. You can use the Parameter /// Groups option of the Amazon RDS /// console or the DescribeDBClusterParameters operation to verify that /// your DB cluster parameter group has been created or modified. /// /// /// /// For more information on Amazon Aurora, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the CreateDBClusterParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDBClusterParameterGroup service method, as returned by RDS. /// /// A DB parameter group with the same name exists. /// /// /// The request would result in the user exceeding the allowed number of DB parameter /// groups. /// /// REST API Reference for CreateDBClusterParameterGroup Operation public virtual Task CreateDBClusterParameterGroupAsync(CreateDBClusterParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBClusterParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDBClusterSnapshot internal virtual CreateDBClusterSnapshotResponse CreateDBClusterSnapshot(CreateDBClusterSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBClusterSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a snapshot of a DB cluster. /// /// /// /// For more information on Amazon Aurora, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the CreateDBClusterSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDBClusterSnapshot service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// The user already has a DB cluster snapshot with the given identifier. /// /// /// The supplied value isn't a valid DB cluster snapshot state. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The request would result in the user exceeding the allowed number of DB snapshots. /// /// REST API Reference for CreateDBClusterSnapshot Operation public virtual Task CreateDBClusterSnapshotAsync(CreateDBClusterSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBClusterSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDBInstance internal virtual CreateDBInstanceResponse CreateDBInstance(CreateDBInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new DB instance. /// /// /// /// The new DB instance can be an RDS DB instance, or it can be a DB instance in an Aurora /// DB cluster. For an Aurora DB cluster, you can call this operation multiple times to /// add more than one DB instance to the cluster. /// /// /// /// For more information about creating an RDS DB instance, see /// Creating an Amazon RDS DB instance in the Amazon RDS User Guide. /// /// /// /// For more information about creating a DB instance in an Aurora DB cluster, see /// Creating an Amazon Aurora DB cluster in the Amazon Aurora User Guide. /// ///

/// Container for the necessary parameters to execute the CreateDBInstance service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDBInstance service method, as returned by RDS. /// /// The specified CIDR IP range or Amazon EC2 security group might not be authorized for /// the specified DB security group. /// /// /// /// Or, RDS might not be authorized to perform necessary actions using IAM on your behalf. /// /// /// /// /// /// /// CertificateIdentifier doesn't refer to an existing certificate. /// /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// The user already has a DB instance with the given identifier. /// /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// DBSecurityGroupName doesn't refer to an existing DB security group. /// /// /// Subnets in the DB subnet group should cover at least two Availability Zones unless /// there is only one Availability Zone. /// /// /// DBSubnetGroupName doesn't refer to an existing DB subnet group. /// /// /// Domain doesn't refer to an existing Active Directory domain. /// /// /// The request would result in the user exceeding the allowed number of DB instances. /// /// /// The specified DB instance class isn't available in the specified Availability Zone. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The requested subnet is invalid, or multiple subnets were requested that are not all /// in a common VPC. /// /// /// The DB subnet group doesn't cover all Availability Zones after it's created because /// of users' change. /// /// /// An error occurred accessing an Amazon Web Services KMS key. /// /// /// The network type is invalid for the DB instance. Valid nework type values are IPV4 /// and DUAL. /// /// /// The specified option group could not be found. /// /// /// Provisioned IOPS not available in the specified Availability Zone. /// /// /// The request would result in the user exceeding the allowed amount of storage available /// across all DB instances. /// /// /// The specified StorageType can't be associated with the DB instance. /// /// REST API Reference for CreateDBInstance Operation public virtual Task CreateDBInstanceAsync(CreateDBInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBInstanceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDBInstanceReadReplica internal virtual CreateDBInstanceReadReplicaResponse CreateDBInstanceReadReplica(CreateDBInstanceReadReplicaRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBInstanceReadReplicaRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBInstanceReadReplicaResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new DB instance that acts as a read replica for an existing source DB instance /// or Multi-AZ DB cluster. You can create a read replica for a DB instance running MySQL, /// MariaDB, Oracle, PostgreSQL, or SQL Server. You can create a read replica for a Multi-AZ /// DB cluster running MySQL or PostgreSQL. For more information, see Working /// with read replicas and Migrating /// from a Multi-AZ DB cluster to a DB instance using a read replica in the Amazon /// RDS User Guide. /// /// /// /// Amazon Aurora doesn't support this operation. Call the CreateDBInstance /// operation to create a DB instance for an Aurora DB cluster. /// /// /// /// All read replica DB instances are created with backups disabled. All other attributes /// (including DB security groups and DB parameter groups) are inherited from the source /// DB instance or cluster, except as specified. /// /// /// /// Your source DB instance or cluster must have backup retention enabled. /// /// ///

/// Container for the necessary parameters to execute the CreateDBInstanceReadReplica service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDBInstanceReadReplica service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// The user already has a DB instance with the given identifier. /// /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// DBSecurityGroupName doesn't refer to an existing DB security group. /// /// /// Subnets in the DB subnet group should cover at least two Availability Zones unless /// there is only one Availability Zone. /// /// /// The DBSubnetGroup shouldn't be specified while creating read replicas that lie in /// the same region as the source instance. /// /// /// DBSubnetGroupName doesn't refer to an existing DB subnet group. /// /// /// Domain doesn't refer to an existing Active Directory domain. /// /// /// The request would result in the user exceeding the allowed number of DB instances. /// /// /// The specified DB instance class isn't available in the specified Availability Zone. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB instance isn't in a valid state. /// /// /// The DBSubnetGroup doesn't belong to the same VPC as that of an existing cross-region /// read replica of the same source instance. /// /// /// The requested subnet is invalid, or multiple subnets were requested that are not all /// in a common VPC. /// /// /// The DB subnet group doesn't cover all Availability Zones after it's created because /// of users' change. /// /// /// An error occurred accessing an Amazon Web Services KMS key. /// /// /// The network type is invalid for the DB instance. Valid nework type values are IPV4 /// and DUAL. /// /// /// The specified option group could not be found. /// /// /// Provisioned IOPS not available in the specified Availability Zone. /// /// /// The request would result in the user exceeding the allowed amount of storage available /// across all DB instances. /// /// /// The specified StorageType can't be associated with the DB instance. /// /// REST API Reference for CreateDBInstanceReadReplica Operation public virtual Task CreateDBInstanceReadReplicaAsync(CreateDBInstanceReadReplicaRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBInstanceReadReplicaRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBInstanceReadReplicaResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDBParameterGroup internal virtual CreateDBParameterGroupResponse CreateDBParameterGroup(CreateDBParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new DB parameter group. /// /// /// /// A DB parameter group is initially created with the default parameters for the database /// engine used by the DB instance. To provide custom values for any of the parameters, /// you must modify the group after creating it using ModifyDBParameterGroup. /// Once you've created a DB parameter group, you need to associate it with your DB instance /// using ModifyDBInstance. When you associate a new DB parameter group with /// a running DB instance, you need to reboot the DB instance without failover for the /// new DB parameter group and associated settings to take effect. /// /// /// /// This command doesn't apply to RDS Custom. /// /// /// /// After you create a DB parameter group, you should wait at least 5 minutes before creating /// your first DB instance that uses that DB parameter group as the default parameter /// group. This allows Amazon RDS to fully complete the create action before the parameter /// group is used as the default for a new DB instance. This is especially important for /// parameters that are critical when creating the default database for a DB instance, /// such as the character set for the default database defined by the character_set_database /// parameter. You can use the Parameter Groups option of the Amazon /// RDS console or the DescribeDBParameters command to verify that your DB /// parameter group has been created or modified. /// /// ///

/// Container for the necessary parameters to execute the CreateDBParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDBParameterGroup service method, as returned by RDS. /// /// A DB parameter group with the same name exists. /// /// /// The request would result in the user exceeding the allowed number of DB parameter /// groups. /// /// REST API Reference for CreateDBParameterGroup Operation public virtual Task CreateDBParameterGroupAsync(CreateDBParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDBProxy internal virtual CreateDBProxyResponse CreateDBProxy(CreateDBProxyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBProxyRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBProxyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new DB proxy. ///

/// Container for the necessary parameters to execute the CreateDBProxy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDBProxy service method, as returned by RDS. /// /// The specified proxy name must be unique for all proxies owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// Your Amazon Web Services account already has the maximum number of proxies in the /// specified Amazon Web Services Region. /// /// /// The requested subnet is invalid, or multiple subnets were requested that are not all /// in a common VPC. /// /// REST API Reference for CreateDBProxy Operation public virtual Task CreateDBProxyAsync(CreateDBProxyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBProxyRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBProxyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDBProxyEndpoint internal virtual CreateDBProxyEndpointResponse CreateDBProxyEndpoint(CreateDBProxyEndpointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBProxyEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBProxyEndpointResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a DBProxyEndpoint. Only applies to proxies that are associated /// with Aurora DB clusters. You can use DB proxy endpoints to specify read/write or read-only /// access to the DB cluster. You can also use DB proxy endpoints to access a DB proxy /// through a different VPC than the proxy's default VPC. ///

/// Container for the necessary parameters to execute the CreateDBProxyEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDBProxyEndpoint service method, as returned by RDS. /// /// The specified DB proxy endpoint name must be unique for all DB proxy endpoints owned /// by your Amazon Web Services account in the specified Amazon Web Services Region. /// /// /// The DB proxy already has the maximum number of endpoints. /// /// /// The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The requested operation can't be performed while the proxy is in this state. /// /// /// The requested subnet is invalid, or multiple subnets were requested that are not all /// in a common VPC. /// /// REST API Reference for CreateDBProxyEndpoint Operation public virtual Task CreateDBProxyEndpointAsync(CreateDBProxyEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBProxyEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBProxyEndpointResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDBSecurityGroup internal virtual CreateDBSecurityGroupResponse CreateDBSecurityGroup(CreateDBSecurityGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBSecurityGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBSecurityGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new DB security group. DB security groups control access to a DB instance. /// /// /// /// A DB security group controls access to EC2-Classic DB instances that are not in a /// VPC. /// /// /// /// EC2-Classic was retired on August 15, 2022. If you haven't migrated from EC2-Classic /// to a VPC, we recommend that you migrate as soon as possible. For more information, /// see Migrate /// from EC2-Classic to a VPC in the Amazon EC2 User Guide, the blog EC2-Classic /// Networking is Retiring – Here’s How to Prepare, and Moving /// a DB instance not in a VPC into a VPC in the Amazon RDS User Guide. /// /// ///

/// Container for the necessary parameters to execute the CreateDBSecurityGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDBSecurityGroup service method, as returned by RDS. /// /// A DB security group with the name specified in DBSecurityGroupName already /// exists. /// /// /// A DB security group isn't allowed for this action. /// /// /// The request would result in the user exceeding the allowed number of DB security groups. /// /// REST API Reference for CreateDBSecurityGroup Operation public virtual Task CreateDBSecurityGroupAsync(CreateDBSecurityGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBSecurityGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBSecurityGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDBSnapshot internal virtual CreateDBSnapshotResponse CreateDBSnapshot(CreateDBSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a snapshot of a DB instance. The source DB instance must be in the available /// or storage-optimization state. ///

/// Container for the necessary parameters to execute the CreateDBSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDBSnapshot service method, as returned by RDS. /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// DBSnapshotIdentifier is already used by an existing snapshot. /// /// /// The DB instance isn't in a valid state. /// /// /// The request would result in the user exceeding the allowed number of DB snapshots. /// /// REST API Reference for CreateDBSnapshot Operation public virtual Task CreateDBSnapshotAsync(CreateDBSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDBSubnetGroup internal virtual CreateDBSubnetGroupResponse CreateDBSubnetGroup(CreateDBSubnetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBSubnetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new DB subnet group. DB subnet groups must contain at least one subnet in /// at least two AZs in the Amazon Web Services Region. ///

/// Container for the necessary parameters to execute the CreateDBSubnetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDBSubnetGroup service method, as returned by RDS. /// /// DBSubnetGroupName is already used by an existing DB subnet group. /// /// /// Subnets in the DB subnet group should cover at least two Availability Zones unless /// there is only one Availability Zone. /// /// /// The request would result in the user exceeding the allowed number of DB subnet groups. /// /// /// The request would result in the user exceeding the allowed number of subnets in a /// DB subnet groups. /// /// /// The requested subnet is invalid, or multiple subnets were requested that are not all /// in a common VPC. /// /// REST API Reference for CreateDBSubnetGroup Operation public virtual Task CreateDBSubnetGroupAsync(CreateDBSubnetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDBSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDBSubnetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateEventSubscription internal virtual CreateEventSubscriptionResponse CreateEventSubscription(CreateEventSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEventSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEventSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates an RDS event notification subscription. This operation requires a topic Amazon /// Resource Name (ARN) created by either the RDS console, the SNS console, or the SNS /// API. To obtain an ARN with SNS, you must create a topic in Amazon SNS and subscribe /// to the topic. The ARN is displayed in the SNS console. /// /// /// /// You can specify the type of source (SourceType) that you want to be notified /// of and provide a list of RDS sources (SourceIds) that triggers the events. /// You can also provide a list of event categories (EventCategories) for /// events that you want to be notified of. For example, you can specify SourceType /// = db-instance, SourceIds = mydbinstance1, mydbinstance2 /// and EventCategories = Availability, Backup. /// /// /// /// If you specify both the SourceType and SourceIds, such as /// SourceType = db-instance and SourceIds = myDBInstance1, /// you are notified of all the db-instance events for the specified source. /// If you specify a SourceType but do not specify SourceIds, /// you receive notice of the events for that source type for all your RDS sources. If /// you don't specify either the SourceType or the SourceIds, you are notified /// of events generated from all RDS sources belonging to your customer account. /// /// /// /// For more information about subscribing to an event for RDS DB engines, see /// Subscribing to Amazon RDS event notification in the Amazon RDS User Guide. /// /// /// /// For more information about subscribing to an event for Aurora DB engines, see /// Subscribing to Amazon RDS event notification in the Amazon Aurora User Guide. /// ///

/// Container for the necessary parameters to execute the CreateEventSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateEventSubscription service method, as returned by RDS. /// /// You have reached the maximum number of event subscriptions. /// /// /// SNS has responded that there is a problem with the SNS topic specified. /// /// /// You do not have permission to publish to the SNS topic ARN. /// /// /// The SNS topic ARN does not exist. /// /// /// The requested source could not be found. /// /// /// The supplied subscription name already exists. /// /// /// The supplied category does not exist. /// /// REST API Reference for CreateEventSubscription Operation public virtual Task CreateEventSubscriptionAsync(CreateEventSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEventSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEventSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateGlobalCluster internal virtual CreateGlobalClusterResponse CreateGlobalCluster(CreateGlobalClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateGlobalClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateGlobalClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates an Aurora global database spread across multiple Amazon Web Services Regions. /// The global database contains a single primary cluster with read-write capability, /// and a read-only secondary cluster that receives data from the primary cluster through /// high-speed replication performed by the Aurora storage subsystem. /// /// /// /// You can create a global database that is initially empty, and then create the primary /// and secondary DB clusters in the global database. Or you can specify an existing Aurora /// cluster during the create operation, and this cluster becomes the primary cluster /// of the global database. /// /// /// /// This operation applies only to Aurora DB clusters. /// /// ///

/// Container for the necessary parameters to execute the CreateGlobalCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateGlobalCluster service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// The GlobalClusterIdentifier already exists. Choose a new global database /// identifier (unique name) to create a new global database cluster. /// /// /// The number of global database clusters for this account is already at the maximum /// allowed. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// REST API Reference for CreateGlobalCluster Operation public virtual Task CreateGlobalClusterAsync(CreateGlobalClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateGlobalClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateGlobalClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateOptionGroup internal virtual CreateOptionGroupResponse CreateOptionGroup(CreateOptionGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateOptionGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateOptionGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new option group. You can create up to 20 option groups. /// /// /// /// This command doesn't apply to RDS Custom. /// ///

/// Container for the necessary parameters to execute the CreateOptionGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateOptionGroup service method, as returned by RDS. /// /// The option group you are trying to create already exists. /// /// /// The quota of 20 option groups was exceeded for this Amazon Web Services account. /// /// REST API Reference for CreateOptionGroup Operation public virtual Task CreateOptionGroupAsync(CreateOptionGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateOptionGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateOptionGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteBlueGreenDeployment internal virtual DeleteBlueGreenDeploymentResponse DeleteBlueGreenDeployment(DeleteBlueGreenDeploymentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteBlueGreenDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteBlueGreenDeploymentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a blue/green deployment. /// /// /// /// For more information, see Using /// Amazon RDS Blue/Green Deployments for database updates in the Amazon RDS User /// Guide and Using /// Amazon RDS Blue/Green Deployments for database updates in the Amazon Aurora /// User Guide. /// ///

/// Container for the necessary parameters to execute the DeleteBlueGreenDeployment service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteBlueGreenDeployment service method, as returned by RDS. /// /// BlueGreenDeploymentIdentifier doesn't refer to an existing blue/green /// deployment. /// /// /// The blue/green deployment can't be switched over or deleted because there is an invalid /// configuration in the green environment. /// /// REST API Reference for DeleteBlueGreenDeployment Operation public virtual Task DeleteBlueGreenDeploymentAsync(DeleteBlueGreenDeploymentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteBlueGreenDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteBlueGreenDeploymentResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteCustomDBEngineVersion internal virtual DeleteCustomDBEngineVersionResponse DeleteCustomDBEngineVersion(DeleteCustomDBEngineVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCustomDBEngineVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCustomDBEngineVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a custom engine version. To run this command, make sure you meet the following /// prerequisites: /// ///

/// /// The CEV must not be the default for RDS Custom. If it is, change the default before /// running this command. /// ///
/// /// The CEV must not be associated with an RDS Custom DB instance, RDS Custom instance /// snapshot, or automated backup of your RDS Custom instance. /// ///

/// /// Typically, deletion takes a few minutes. /// /// /// /// The MediaImport service that imports files from Amazon S3 to create CEVs isn't integrated /// with Amazon Web Services CloudTrail. If you turn on data logging for Amazon RDS in /// CloudTrail, calls to the DeleteCustomDbEngineVersion event aren't logged. /// However, you might see calls from the API gateway that accesses your Amazon S3 bucket. /// These calls originate from the MediaImport service for the DeleteCustomDbEngineVersion /// event. /// /// /// /// For more information, see Deleting /// a CEV in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the DeleteCustomDBEngineVersion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteCustomDBEngineVersion service method, as returned by RDS. /// /// The specified CEV was not found. /// /// /// You can't delete the CEV. /// /// REST API Reference for DeleteCustomDBEngineVersion Operation public virtual Task DeleteCustomDBEngineVersionAsync(DeleteCustomDBEngineVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCustomDBEngineVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCustomDBEngineVersionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDBCluster internal virtual DeleteDBClusterResponse DeleteDBCluster(DeleteDBClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// The DeleteDBCluster action deletes a previously provisioned DB cluster. When you delete /// a DB cluster, all automated backups for that DB cluster are deleted and can't be recovered. /// Manual DB cluster snapshots of the specified DB cluster are not deleted. /// /// /// /// If you're deleting a Multi-AZ DB cluster with read replicas, all cluster members are /// terminated and read replicas are promoted to standalone instances. /// /// /// /// For more information on Amazon Aurora, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the DeleteDBCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDBCluster service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// The user already has a DB cluster snapshot with the given identifier. /// /// /// The supplied value isn't a valid DB cluster snapshot state. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The request would result in the user exceeding the allowed number of DB snapshots. /// /// REST API Reference for DeleteDBCluster Operation public virtual Task DeleteDBClusterAsync(DeleteDBClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDBClusterEndpoint internal virtual DeleteDBClusterEndpointResponse DeleteDBClusterEndpoint(DeleteDBClusterEndpointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBClusterEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBClusterEndpointResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a custom endpoint and removes it from an Amazon Aurora DB cluster. /// /// /// /// This action only applies to Aurora DB clusters. /// /// ///

/// Container for the necessary parameters to execute the DeleteDBClusterEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDBClusterEndpoint service method, as returned by RDS. /// /// The specified custom endpoint doesn't exist. /// /// /// The requested operation can't be performed on the endpoint while the endpoint is in /// this state. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// REST API Reference for DeleteDBClusterEndpoint Operation public virtual Task DeleteDBClusterEndpointAsync(DeleteDBClusterEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBClusterEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBClusterEndpointResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDBClusterParameterGroup internal virtual DeleteDBClusterParameterGroupResponse DeleteDBClusterParameterGroup(DeleteDBClusterParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBClusterParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a specified DB cluster parameter group. The DB cluster parameter group to /// be deleted can't be associated with any DB clusters. /// /// /// /// For more information on Amazon Aurora, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the DeleteDBClusterParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDBClusterParameterGroup service method, as returned by RDS. /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// The DB parameter group is in use or is in an invalid state. If you are attempting /// to delete the parameter group, you can't delete it when the parameter group is in /// this state. /// /// REST API Reference for DeleteDBClusterParameterGroup Operation public virtual Task DeleteDBClusterParameterGroupAsync(DeleteDBClusterParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBClusterParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDBClusterSnapshot internal virtual DeleteDBClusterSnapshotResponse DeleteDBClusterSnapshot(DeleteDBClusterSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBClusterSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a DB cluster snapshot. If the snapshot is being copied, the copy operation /// is terminated. /// /// /// /// The DB cluster snapshot must be in the available state to be deleted. /// /// /// /// For more information on Amazon Aurora, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the DeleteDBClusterSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDBClusterSnapshot service method, as returned by RDS. /// /// DBClusterSnapshotIdentifier doesn't refer to an existing DB cluster /// snapshot. /// /// /// The supplied value isn't a valid DB cluster snapshot state. /// /// REST API Reference for DeleteDBClusterSnapshot Operation public virtual Task DeleteDBClusterSnapshotAsync(DeleteDBClusterSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBClusterSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDBInstance internal virtual DeleteDBInstanceResponse DeleteDBInstance(DeleteDBInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// The DeleteDBInstance action deletes a previously provisioned DB instance. When you /// delete a DB instance, all automated backups for that instance are deleted and can't /// be recovered. Manual DB snapshots of the DB instance to be deleted by DeleteDBInstance /// are not deleted. /// /// /// /// If you request a final DB snapshot the status of the Amazon RDS DB instance is deleting /// until the DB snapshot is created. The API action DescribeDBInstance is /// used to monitor the status of this operation. The action can't be canceled or reverted /// once submitted. /// /// /// /// When a DB instance is in a failure state and has a status of failed, /// incompatible-restore, or incompatible-network, you can only /// delete it when you skip creation of the final snapshot with the SkipFinalSnapshot /// parameter. /// /// /// /// If the specified DB instance is part of an Amazon Aurora DB cluster, you can't delete /// the DB instance if both of the following conditions are true: /// ///

/// /// The DB cluster is a read replica of another Amazon Aurora DB cluster. /// ///
/// /// The DB instance is the only instance in the DB cluster. /// ///

/// /// To delete a DB instance in this case, first call the PromoteReadReplicaDBCluster /// API action to promote the DB cluster so it's no longer a read replica. After the promotion /// completes, then call the DeleteDBInstance API action to delete the final /// instance in the DB cluster. /// ///

/// Container for the necessary parameters to execute the DeleteDBInstance service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDBInstance service method, as returned by RDS. /// /// The quota for retained automated backups was exceeded. This prevents you from retaining /// any additional automated backups. The retained automated backups quota is the same /// as your DB Instance quota. /// /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// DBSnapshotIdentifier is already used by an existing snapshot. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB instance isn't in a valid state. /// /// /// The request would result in the user exceeding the allowed number of DB snapshots. /// /// REST API Reference for DeleteDBInstance Operation public virtual Task DeleteDBInstanceAsync(DeleteDBInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBInstanceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDBInstanceAutomatedBackup internal virtual DeleteDBInstanceAutomatedBackupResponse DeleteDBInstanceAutomatedBackup(DeleteDBInstanceAutomatedBackupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBInstanceAutomatedBackupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBInstanceAutomatedBackupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes automated backups using the DbiResourceId value of the source /// DB instance or the Amazon Resource Name (ARN) of the automated backups. ///

/// Container for the necessary parameters to execute the DeleteDBInstanceAutomatedBackup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDBInstanceAutomatedBackup service method, as returned by RDS. /// /// No automated backup for this DB instance was found. /// /// /// The automated backup is in an invalid state. For example, this automated backup is /// associated with an active instance. /// /// REST API Reference for DeleteDBInstanceAutomatedBackup Operation public virtual Task DeleteDBInstanceAutomatedBackupAsync(DeleteDBInstanceAutomatedBackupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBInstanceAutomatedBackupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBInstanceAutomatedBackupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDBParameterGroup internal virtual DeleteDBParameterGroupResponse DeleteDBParameterGroup(DeleteDBParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a specified DB parameter group. The DB parameter group to be deleted can't /// be associated with any DB instances. ///

/// Container for the necessary parameters to execute the DeleteDBParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDBParameterGroup service method, as returned by RDS. /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// The DB parameter group is in use or is in an invalid state. If you are attempting /// to delete the parameter group, you can't delete it when the parameter group is in /// this state. /// /// REST API Reference for DeleteDBParameterGroup Operation public virtual Task DeleteDBParameterGroupAsync(DeleteDBParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDBProxy internal virtual DeleteDBProxyResponse DeleteDBProxy(DeleteDBProxyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBProxyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBProxyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes an existing DB proxy. ///

/// Container for the necessary parameters to execute the DeleteDBProxy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDBProxy service method, as returned by RDS. /// /// The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The requested operation can't be performed while the proxy is in this state. /// /// REST API Reference for DeleteDBProxy Operation public virtual Task DeleteDBProxyAsync(DeleteDBProxyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBProxyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBProxyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDBProxyEndpoint internal virtual DeleteDBProxyEndpointResponse DeleteDBProxyEndpoint(DeleteDBProxyEndpointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBProxyEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBProxyEndpointResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a DBProxyEndpoint. Doing so removes the ability to access the /// DB proxy using the endpoint that you defined. The endpoint that you delete might have /// provided capabilities such as read/write or read-only operations, or using a different /// VPC than the DB proxy's default VPC. ///

/// Container for the necessary parameters to execute the DeleteDBProxyEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDBProxyEndpoint service method, as returned by RDS. /// /// The DB proxy endpoint doesn't exist. /// /// /// You can't perform this operation while the DB proxy endpoint is in a particular state. /// /// REST API Reference for DeleteDBProxyEndpoint Operation public virtual Task DeleteDBProxyEndpointAsync(DeleteDBProxyEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBProxyEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBProxyEndpointResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDBSecurityGroup internal virtual DeleteDBSecurityGroupResponse DeleteDBSecurityGroup(DeleteDBSecurityGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBSecurityGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBSecurityGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a DB security group. /// /// /// /// The specified DB security group must not be associated with any DB instances. /// /// /// /// EC2-Classic was retired on August 15, 2022. If you haven't migrated from EC2-Classic /// to a VPC, we recommend that you migrate as soon as possible. For more information, /// see Migrate /// from EC2-Classic to a VPC in the Amazon EC2 User Guide, the blog EC2-Classic /// Networking is Retiring – Here’s How to Prepare, and Moving /// a DB instance not in a VPC into a VPC in the Amazon RDS User Guide. /// /// ///

/// Container for the necessary parameters to execute the DeleteDBSecurityGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDBSecurityGroup service method, as returned by RDS. /// /// DBSecurityGroupName doesn't refer to an existing DB security group. /// /// /// The state of the DB security group doesn't allow deletion. /// /// REST API Reference for DeleteDBSecurityGroup Operation public virtual Task DeleteDBSecurityGroupAsync(DeleteDBSecurityGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBSecurityGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBSecurityGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDBSnapshot internal virtual DeleteDBSnapshotResponse DeleteDBSnapshot(DeleteDBSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a DB snapshot. If the snapshot is being copied, the copy operation is terminated. /// /// /// /// The DB snapshot must be in the available state to be deleted. /// /// ///

/// Container for the necessary parameters to execute the DeleteDBSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDBSnapshot service method, as returned by RDS. /// /// DBSnapshotIdentifier doesn't refer to an existing DB snapshot. /// /// /// The state of the DB snapshot doesn't allow deletion. /// /// REST API Reference for DeleteDBSnapshot Operation public virtual Task DeleteDBSnapshotAsync(DeleteDBSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDBSubnetGroup internal virtual DeleteDBSubnetGroupResponse DeleteDBSubnetGroup(DeleteDBSubnetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBSubnetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a DB subnet group. /// /// /// /// The specified database subnet group must not be associated with any DB instances. /// /// ///

/// Container for the necessary parameters to execute the DeleteDBSubnetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDBSubnetGroup service method, as returned by RDS. /// /// DBSubnetGroupName doesn't refer to an existing DB subnet group. /// /// /// The DB subnet group cannot be deleted because it's in use. /// /// /// The DB subnet isn't in the available state. /// /// REST API Reference for DeleteDBSubnetGroup Operation public virtual Task DeleteDBSubnetGroupAsync(DeleteDBSubnetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDBSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDBSubnetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteEventSubscription internal virtual DeleteEventSubscriptionResponse DeleteEventSubscription(DeleteEventSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteEventSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteEventSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes an RDS event notification subscription. ///

/// Container for the necessary parameters to execute the DeleteEventSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteEventSubscription service method, as returned by RDS. /// /// This error can occur if someone else is modifying a subscription. You should retry /// the action. /// /// /// The subscription name does not exist. /// /// REST API Reference for DeleteEventSubscription Operation public virtual Task DeleteEventSubscriptionAsync(DeleteEventSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteEventSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteEventSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteGlobalCluster internal virtual DeleteGlobalClusterResponse DeleteGlobalCluster(DeleteGlobalClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteGlobalClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteGlobalClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a global database cluster. The primary and secondary clusters must already /// be detached or destroyed first. /// /// /// /// This action only applies to Aurora DB clusters. /// /// ///

/// Container for the necessary parameters to execute the DeleteGlobalCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteGlobalCluster service method, as returned by RDS. /// /// The GlobalClusterIdentifier doesn't refer to an existing global database /// cluster. /// /// /// The global cluster is in an invalid state and can't perform the requested operation. /// /// REST API Reference for DeleteGlobalCluster Operation public virtual Task DeleteGlobalClusterAsync(DeleteGlobalClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteGlobalClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteGlobalClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteOptionGroup internal virtual DeleteOptionGroupResponse DeleteOptionGroup(DeleteOptionGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteOptionGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteOptionGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes an existing option group. ///

/// Container for the necessary parameters to execute the DeleteOptionGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteOptionGroup service method, as returned by RDS. /// /// The option group isn't in the available state. /// /// /// The specified option group could not be found. /// /// REST API Reference for DeleteOptionGroup Operation public virtual Task DeleteOptionGroupAsync(DeleteOptionGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteOptionGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteOptionGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeregisterDBProxyTargets internal virtual DeregisterDBProxyTargetsResponse DeregisterDBProxyTargets(DeregisterDBProxyTargetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterDBProxyTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterDBProxyTargetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Remove the association between one or more DBProxyTarget data structures /// and a DBProxyTargetGroup. ///

/// Container for the necessary parameters to execute the DeregisterDBProxyTargets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeregisterDBProxyTargets service method, as returned by RDS. /// /// The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The specified target group isn't available for a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The specified RDS DB instance or Aurora DB cluster isn't available for a proxy owned /// by your Amazon Web Services account in the specified Amazon Web Services Region. /// /// /// The requested operation can't be performed while the proxy is in this state. /// /// REST API Reference for DeregisterDBProxyTargets Operation public virtual Task DeregisterDBProxyTargetsAsync(DeregisterDBProxyTargetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterDBProxyTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterDBProxyTargetsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAccountAttributes internal virtual DescribeAccountAttributesResponse DescribeAccountAttributes() { return DescribeAccountAttributes(new DescribeAccountAttributesRequest()); } internal virtual DescribeAccountAttributesResponse DescribeAccountAttributes(DescribeAccountAttributesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAccountAttributesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAccountAttributesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Lists all of the attributes for a customer account. The attributes include Amazon /// RDS quotas for the account, such as the number of DB instances allowed. The description /// for a quota includes the quota name, current usage toward that quota, and the quota's /// maximum value. /// /// /// /// This command doesn't take any parameters. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAccountAttributes service method, as returned by RDS. /// REST API Reference for DescribeAccountAttributes Operation public virtual Task DescribeAccountAttributesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeAccountAttributesAsync(new DescribeAccountAttributesRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeAccountAttributes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAccountAttributes service method, as returned by RDS. /// REST API Reference for DescribeAccountAttributes Operation public virtual Task DescribeAccountAttributesAsync(DescribeAccountAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAccountAttributesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAccountAttributesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeBlueGreenDeployments internal virtual DescribeBlueGreenDeploymentsResponse DescribeBlueGreenDeployments(DescribeBlueGreenDeploymentsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeBlueGreenDeploymentsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeBlueGreenDeploymentsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes one or more blue/green deployments. /// /// /// /// For more information, see Using /// Amazon RDS Blue/Green Deployments for database updates in the Amazon RDS User /// Guide and /// Using Amazon RDS Blue/Green Deployments for database updates in the Amazon /// Aurora User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeBlueGreenDeployments service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeBlueGreenDeployments service method, as returned by RDS. /// /// BlueGreenDeploymentIdentifier doesn't refer to an existing blue/green /// deployment. /// /// REST API Reference for DescribeBlueGreenDeployments Operation public virtual Task DescribeBlueGreenDeploymentsAsync(DescribeBlueGreenDeploymentsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeBlueGreenDeploymentsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeBlueGreenDeploymentsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeCertificates internal virtual DescribeCertificatesResponse DescribeCertificates(DescribeCertificatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCertificatesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Lists the set of CA certificates provided by Amazon RDS for this Amazon Web Services /// account. /// /// /// /// For more information, see Using /// SSL/TLS to encrypt a connection to a DB instance in the Amazon RDS User Guide /// and /// Using SSL/TLS to encrypt a connection to a DB cluster in the Amazon Aurora /// User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeCertificates service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeCertificates service method, as returned by RDS. /// /// CertificateIdentifier doesn't refer to an existing certificate. /// /// REST API Reference for DescribeCertificates Operation public virtual Task DescribeCertificatesAsync(DescribeCertificatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCertificatesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBClusterBacktracks internal virtual DescribeDBClusterBacktracksResponse DescribeDBClusterBacktracks(DescribeDBClusterBacktracksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClusterBacktracksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClusterBacktracksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about backtracks for a DB cluster. /// /// /// /// For more information on Amazon Aurora, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// This action only applies to Aurora MySQL DB clusters. /// /// ///

/// Container for the necessary parameters to execute the DescribeDBClusterBacktracks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBClusterBacktracks service method, as returned by RDS. /// /// BacktrackIdentifier doesn't refer to an existing backtrack. /// /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// REST API Reference for DescribeDBClusterBacktracks Operation public virtual Task DescribeDBClusterBacktracksAsync(DescribeDBClusterBacktracksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClusterBacktracksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClusterBacktracksResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBClusterEndpoints internal virtual DescribeDBClusterEndpointsResponse DescribeDBClusterEndpoints(DescribeDBClusterEndpointsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClusterEndpointsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClusterEndpointsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about endpoints for an Amazon Aurora DB cluster. /// /// /// /// This action only applies to Aurora DB clusters. /// /// ///

/// Container for the necessary parameters to execute the DescribeDBClusterEndpoints service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBClusterEndpoints service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// REST API Reference for DescribeDBClusterEndpoints Operation public virtual Task DescribeDBClusterEndpointsAsync(DescribeDBClusterEndpointsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClusterEndpointsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClusterEndpointsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBClusterParameterGroups internal virtual DescribeDBClusterParameterGroupsResponse DescribeDBClusterParameterGroups(DescribeDBClusterParameterGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClusterParameterGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClusterParameterGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of DBClusterParameterGroup descriptions. If a DBClusterParameterGroupName /// parameter is specified, the list will contain only the description of the specified /// DB cluster parameter group. /// /// /// /// For more information on Amazon Aurora, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeDBClusterParameterGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBClusterParameterGroups service method, as returned by RDS. /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// REST API Reference for DescribeDBClusterParameterGroups Operation public virtual Task DescribeDBClusterParameterGroupsAsync(DescribeDBClusterParameterGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClusterParameterGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClusterParameterGroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBClusterParameters internal virtual DescribeDBClusterParametersResponse DescribeDBClusterParameters(DescribeDBClusterParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClusterParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClusterParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns the detailed parameter list for a particular DB cluster parameter group. /// /// /// /// For more information on Amazon Aurora, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeDBClusterParameters service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBClusterParameters service method, as returned by RDS. /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// REST API Reference for DescribeDBClusterParameters Operation public virtual Task DescribeDBClusterParametersAsync(DescribeDBClusterParametersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClusterParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClusterParametersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBClusters internal virtual DescribeDBClustersResponse DescribeDBClusters(DescribeDBClustersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClustersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClustersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes existing Amazon Aurora DB clusters and Multi-AZ DB clusters. This API supports /// pagination. /// /// /// /// For more information on Amazon Aurora DB clusters, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// /// /// /// This operation can also return information for Amazon Neptune DB instances and Amazon /// DocumentDB instances. /// ///

/// Container for the necessary parameters to execute the DescribeDBClusters service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBClusters service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// REST API Reference for DescribeDBClusters Operation public virtual Task DescribeDBClustersAsync(DescribeDBClustersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClustersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClustersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBClusterSnapshotAttributes internal virtual DescribeDBClusterSnapshotAttributesResponse DescribeDBClusterSnapshotAttributes(DescribeDBClusterSnapshotAttributesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClusterSnapshotAttributesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClusterSnapshotAttributesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of DB cluster snapshot attribute names and values for a manual DB cluster /// snapshot. /// /// /// /// When sharing snapshots with other Amazon Web Services accounts, DescribeDBClusterSnapshotAttributes /// returns the restore attribute and a list of IDs for the Amazon Web Services /// accounts that are authorized to copy or restore the manual DB cluster snapshot. If /// all is included in the list of values for the restore attribute, /// then the manual DB cluster snapshot is public and can be copied or restored by all /// Amazon Web Services accounts. /// /// /// /// To add or remove access for an Amazon Web Services account to copy or restore a manual /// DB cluster snapshot, or to make the manual DB cluster snapshot public or private, /// use the ModifyDBClusterSnapshotAttribute API action. /// ///

/// Container for the necessary parameters to execute the DescribeDBClusterSnapshotAttributes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBClusterSnapshotAttributes service method, as returned by RDS. /// /// DBClusterSnapshotIdentifier doesn't refer to an existing DB cluster /// snapshot. /// /// REST API Reference for DescribeDBClusterSnapshotAttributes Operation public virtual Task DescribeDBClusterSnapshotAttributesAsync(DescribeDBClusterSnapshotAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClusterSnapshotAttributesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClusterSnapshotAttributesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBClusterSnapshots internal virtual DescribeDBClusterSnapshotsResponse DescribeDBClusterSnapshots(DescribeDBClusterSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClusterSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClusterSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about DB cluster snapshots. This API action supports pagination. /// /// /// /// For more information on Amazon Aurora DB clusters, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeDBClusterSnapshots service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBClusterSnapshots service method, as returned by RDS. /// /// DBClusterSnapshotIdentifier doesn't refer to an existing DB cluster /// snapshot. /// /// REST API Reference for DescribeDBClusterSnapshots Operation public virtual Task DescribeDBClusterSnapshotsAsync(DescribeDBClusterSnapshotsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBClusterSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBClusterSnapshotsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBEngineVersions internal virtual DescribeDBEngineVersionsResponse DescribeDBEngineVersions() { return DescribeDBEngineVersions(new DescribeDBEngineVersionsRequest()); } internal virtual DescribeDBEngineVersionsResponse DescribeDBEngineVersions(DescribeDBEngineVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBEngineVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBEngineVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of the available DB engines. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBEngineVersions service method, as returned by RDS. /// REST API Reference for DescribeDBEngineVersions Operation public virtual Task DescribeDBEngineVersionsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeDBEngineVersionsAsync(new DescribeDBEngineVersionsRequest(), cancellationToken); } ///

/// Returns a list of the available DB engines. ///

/// Container for the necessary parameters to execute the DescribeDBEngineVersions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBEngineVersions service method, as returned by RDS. /// REST API Reference for DescribeDBEngineVersions Operation public virtual Task DescribeDBEngineVersionsAsync(DescribeDBEngineVersionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBEngineVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBEngineVersionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBInstanceAutomatedBackups internal virtual DescribeDBInstanceAutomatedBackupsResponse DescribeDBInstanceAutomatedBackups(DescribeDBInstanceAutomatedBackupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBInstanceAutomatedBackupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBInstanceAutomatedBackupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Displays backups for both current and deleted instances. For example, use this operation /// to find details about automated backups for previously deleted instances. Current /// instances with retention periods greater than zero (0) are returned for both the DescribeDBInstanceAutomatedBackups /// and DescribeDBInstances operations. /// /// /// /// All parameters are optional. /// ///

/// Container for the necessary parameters to execute the DescribeDBInstanceAutomatedBackups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBInstanceAutomatedBackups service method, as returned by RDS. /// /// No automated backup for this DB instance was found. /// /// REST API Reference for DescribeDBInstanceAutomatedBackups Operation public virtual Task DescribeDBInstanceAutomatedBackupsAsync(DescribeDBInstanceAutomatedBackupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBInstanceAutomatedBackupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBInstanceAutomatedBackupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBInstances internal virtual DescribeDBInstancesResponse DescribeDBInstances() { return DescribeDBInstances(new DescribeDBInstancesRequest()); } internal virtual DescribeDBInstancesResponse DescribeDBInstances(DescribeDBInstancesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBInstancesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBInstancesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes provisioned RDS instances. This API supports pagination. /// /// /// /// This operation can also return information for Amazon Neptune DB instances and Amazon /// DocumentDB instances. /// /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBInstances service method, as returned by RDS. /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// REST API Reference for DescribeDBInstances Operation public virtual Task DescribeDBInstancesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeDBInstancesAsync(new DescribeDBInstancesRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeDBInstances service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBInstances service method, as returned by RDS. /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// REST API Reference for DescribeDBInstances Operation public virtual Task DescribeDBInstancesAsync(DescribeDBInstancesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBInstancesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBInstancesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBLogFiles internal virtual DescribeDBLogFilesResponse DescribeDBLogFiles(DescribeDBLogFilesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBLogFilesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBLogFilesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of DB log files for the DB instance. /// /// /// /// This command doesn't apply to RDS Custom. /// ///

/// Container for the necessary parameters to execute the DescribeDBLogFiles service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBLogFiles service method, as returned by RDS. /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// REST API Reference for DescribeDBLogFiles Operation public virtual Task DescribeDBLogFilesAsync(DescribeDBLogFilesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBLogFilesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBLogFilesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBParameterGroups internal virtual DescribeDBParameterGroupsResponse DescribeDBParameterGroups() { return DescribeDBParameterGroups(new DescribeDBParameterGroupsRequest()); } internal virtual DescribeDBParameterGroupsResponse DescribeDBParameterGroups(DescribeDBParameterGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBParameterGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBParameterGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of DBParameterGroup descriptions. If a DBParameterGroupName /// is specified, the list will contain only the description of the specified DB parameter /// group. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBParameterGroups service method, as returned by RDS. /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// REST API Reference for DescribeDBParameterGroups Operation public virtual Task DescribeDBParameterGroupsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeDBParameterGroupsAsync(new DescribeDBParameterGroupsRequest(), cancellationToken); } ///

/// Returns a list of DBParameterGroup descriptions. If a DBParameterGroupName /// is specified, the list will contain only the description of the specified DB parameter /// group. ///

/// Container for the necessary parameters to execute the DescribeDBParameterGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBParameterGroups service method, as returned by RDS. /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// REST API Reference for DescribeDBParameterGroups Operation public virtual Task DescribeDBParameterGroupsAsync(DescribeDBParameterGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBParameterGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBParameterGroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBParameters internal virtual DescribeDBParametersResponse DescribeDBParameters(DescribeDBParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeDBParameters service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBParameters service method, as returned by RDS. /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// REST API Reference for DescribeDBParameters Operation public virtual Task DescribeDBParametersAsync(DescribeDBParametersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBParametersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBProxies internal virtual DescribeDBProxiesResponse DescribeDBProxies(DescribeDBProxiesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBProxiesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBProxiesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about DB proxies. ///

/// Container for the necessary parameters to execute the DescribeDBProxies service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBProxies service method, as returned by RDS. /// /// The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// REST API Reference for DescribeDBProxies Operation public virtual Task DescribeDBProxiesAsync(DescribeDBProxiesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBProxiesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBProxiesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBProxyEndpoints internal virtual DescribeDBProxyEndpointsResponse DescribeDBProxyEndpoints(DescribeDBProxyEndpointsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBProxyEndpointsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBProxyEndpointsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about DB proxy endpoints. ///

/// Container for the necessary parameters to execute the DescribeDBProxyEndpoints service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBProxyEndpoints service method, as returned by RDS. /// /// The DB proxy endpoint doesn't exist. /// /// /// The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// REST API Reference for DescribeDBProxyEndpoints Operation public virtual Task DescribeDBProxyEndpointsAsync(DescribeDBProxyEndpointsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBProxyEndpointsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBProxyEndpointsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBProxyTargetGroups internal virtual DescribeDBProxyTargetGroupsResponse DescribeDBProxyTargetGroups(DescribeDBProxyTargetGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBProxyTargetGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBProxyTargetGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about DB proxy target groups, represented by DBProxyTargetGroup /// data structures. ///

/// Container for the necessary parameters to execute the DescribeDBProxyTargetGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBProxyTargetGroups service method, as returned by RDS. /// /// The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The specified target group isn't available for a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The requested operation can't be performed while the proxy is in this state. /// /// REST API Reference for DescribeDBProxyTargetGroups Operation public virtual Task DescribeDBProxyTargetGroupsAsync(DescribeDBProxyTargetGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBProxyTargetGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBProxyTargetGroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBProxyTargets internal virtual DescribeDBProxyTargetsResponse DescribeDBProxyTargets(DescribeDBProxyTargetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBProxyTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBProxyTargetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about DBProxyTarget objects. This API supports pagination. ///

/// Container for the necessary parameters to execute the DescribeDBProxyTargets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBProxyTargets service method, as returned by RDS. /// /// The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The specified target group isn't available for a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The specified RDS DB instance or Aurora DB cluster isn't available for a proxy owned /// by your Amazon Web Services account in the specified Amazon Web Services Region. /// /// /// The requested operation can't be performed while the proxy is in this state. /// /// REST API Reference for DescribeDBProxyTargets Operation public virtual Task DescribeDBProxyTargetsAsync(DescribeDBProxyTargetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBProxyTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBProxyTargetsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBSecurityGroups internal virtual DescribeDBSecurityGroupsResponse DescribeDBSecurityGroups() { return DescribeDBSecurityGroups(new DescribeDBSecurityGroupsRequest()); } internal virtual DescribeDBSecurityGroupsResponse DescribeDBSecurityGroups(DescribeDBSecurityGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBSecurityGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBSecurityGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of DBSecurityGroup descriptions. If a DBSecurityGroupName /// is specified, the list will contain only the descriptions of the specified DB security /// group. /// /// /// /// EC2-Classic was retired on August 15, 2022. If you haven't migrated from EC2-Classic /// to a VPC, we recommend that you migrate as soon as possible. For more information, /// see Migrate /// from EC2-Classic to a VPC in the Amazon EC2 User Guide, the blog EC2-Classic /// Networking is Retiring – Here’s How to Prepare, and Moving /// a DB instance not in a VPC into a VPC in the Amazon RDS User Guide. /// /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBSecurityGroups service method, as returned by RDS. /// /// DBSecurityGroupName doesn't refer to an existing DB security group. /// /// REST API Reference for DescribeDBSecurityGroups Operation public virtual Task DescribeDBSecurityGroupsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeDBSecurityGroupsAsync(new DescribeDBSecurityGroupsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeDBSecurityGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBSecurityGroups service method, as returned by RDS. /// /// DBSecurityGroupName doesn't refer to an existing DB security group. /// /// REST API Reference for DescribeDBSecurityGroups Operation public virtual Task DescribeDBSecurityGroupsAsync(DescribeDBSecurityGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBSecurityGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBSecurityGroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBSnapshotAttributes internal virtual DescribeDBSnapshotAttributesResponse DescribeDBSnapshotAttributes(DescribeDBSnapshotAttributesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBSnapshotAttributesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBSnapshotAttributesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of DB snapshot attribute names and values for a manual DB snapshot. /// /// /// /// When sharing snapshots with other Amazon Web Services accounts, DescribeDBSnapshotAttributes /// returns the restore attribute and a list of IDs for the Amazon Web Services /// accounts that are authorized to copy or restore the manual DB snapshot. If all /// is included in the list of values for the restore attribute, then the /// manual DB snapshot is public and can be copied or restored by all Amazon Web Services /// accounts. /// /// /// /// To add or remove access for an Amazon Web Services account to copy or restore a manual /// DB snapshot, or to make the manual DB snapshot public or private, use the ModifyDBSnapshotAttribute /// API action. /// ///

/// Container for the necessary parameters to execute the DescribeDBSnapshotAttributes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBSnapshotAttributes service method, as returned by RDS. /// /// DBSnapshotIdentifier doesn't refer to an existing DB snapshot. /// /// REST API Reference for DescribeDBSnapshotAttributes Operation public virtual Task DescribeDBSnapshotAttributesAsync(DescribeDBSnapshotAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBSnapshotAttributesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBSnapshotAttributesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBSnapshots internal virtual DescribeDBSnapshotsResponse DescribeDBSnapshots() { return DescribeDBSnapshots(new DescribeDBSnapshotsRequest()); } internal virtual DescribeDBSnapshotsResponse DescribeDBSnapshots(DescribeDBSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about DB snapshots. This API action supports pagination. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBSnapshots service method, as returned by RDS. /// /// DBSnapshotIdentifier doesn't refer to an existing DB snapshot. /// /// REST API Reference for DescribeDBSnapshots Operation public virtual Task DescribeDBSnapshotsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeDBSnapshotsAsync(new DescribeDBSnapshotsRequest(), cancellationToken); } ///

/// Returns information about DB snapshots. This API action supports pagination. ///

/// Container for the necessary parameters to execute the DescribeDBSnapshots service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBSnapshots service method, as returned by RDS. /// /// DBSnapshotIdentifier doesn't refer to an existing DB snapshot. /// /// REST API Reference for DescribeDBSnapshots Operation public virtual Task DescribeDBSnapshotsAsync(DescribeDBSnapshotsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBSnapshotsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDBSubnetGroups internal virtual DescribeDBSubnetGroupsResponse DescribeDBSubnetGroups() { return DescribeDBSubnetGroups(new DescribeDBSubnetGroupsRequest()); } internal virtual DescribeDBSubnetGroupsResponse DescribeDBSubnetGroups(DescribeDBSubnetGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBSubnetGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBSubnetGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of DBSubnetGroup descriptions. If a DBSubnetGroupName is specified, /// the list will contain only the descriptions of the specified DBSubnetGroup. /// /// /// /// For an overview of CIDR ranges, go to the Wikipedia /// Tutorial. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBSubnetGroups service method, as returned by RDS. /// /// DBSubnetGroupName doesn't refer to an existing DB subnet group. /// /// REST API Reference for DescribeDBSubnetGroups Operation public virtual Task DescribeDBSubnetGroupsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeDBSubnetGroupsAsync(new DescribeDBSubnetGroupsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeDBSubnetGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDBSubnetGroups service method, as returned by RDS. /// /// DBSubnetGroupName doesn't refer to an existing DB subnet group. /// /// REST API Reference for DescribeDBSubnetGroups Operation public virtual Task DescribeDBSubnetGroupsAsync(DescribeDBSubnetGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDBSubnetGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDBSubnetGroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEngineDefaultClusterParameters internal virtual DescribeEngineDefaultClusterParametersResponse DescribeEngineDefaultClusterParameters(DescribeEngineDefaultClusterParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEngineDefaultClusterParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEngineDefaultClusterParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns the default engine and system parameter information for the cluster database /// engine. /// /// /// /// For more information on Amazon Aurora, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeEngineDefaultClusterParameters service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEngineDefaultClusterParameters service method, as returned by RDS. /// REST API Reference for DescribeEngineDefaultClusterParameters Operation public virtual Task DescribeEngineDefaultClusterParametersAsync(DescribeEngineDefaultClusterParametersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEngineDefaultClusterParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEngineDefaultClusterParametersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEngineDefaultParameters internal virtual DescribeEngineDefaultParametersResponse DescribeEngineDefaultParameters(DescribeEngineDefaultParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEngineDefaultParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEngineDefaultParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns the default engine and system parameter information for the specified database /// engine. ///

/// Container for the necessary parameters to execute the DescribeEngineDefaultParameters service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEngineDefaultParameters service method, as returned by RDS. /// REST API Reference for DescribeEngineDefaultParameters Operation public virtual Task DescribeEngineDefaultParametersAsync(DescribeEngineDefaultParametersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEngineDefaultParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEngineDefaultParametersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEventCategories internal virtual DescribeEventCategoriesResponse DescribeEventCategories() { return DescribeEventCategories(new DescribeEventCategoriesRequest()); } internal virtual DescribeEventCategoriesResponse DescribeEventCategories(DescribeEventCategoriesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventCategoriesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventCategoriesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Displays a list of categories for all event source types, or, if specified, for a /// specified source type. You can also see this list in the "Amazon RDS event categories /// and event messages" section of the /// Amazon RDS User Guide or the /// Amazon Aurora User Guide . ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEventCategories service method, as returned by RDS. /// REST API Reference for DescribeEventCategories Operation public virtual Task DescribeEventCategoriesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeEventCategoriesAsync(new DescribeEventCategoriesRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeEventCategories service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEventCategories service method, as returned by RDS. /// REST API Reference for DescribeEventCategories Operation public virtual Task DescribeEventCategoriesAsync(DescribeEventCategoriesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventCategoriesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventCategoriesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEvents internal virtual DescribeEventsResponse DescribeEvents() { return DescribeEvents(new DescribeEventsRequest()); } internal virtual DescribeEventsResponse DescribeEvents(DescribeEventsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns events related to DB instances, DB clusters, DB parameter groups, DB security /// groups, DB snapshots, DB cluster snapshots, and RDS Proxies for the past 14 days. /// Events specific to a particular DB instance, DB cluster, DB parameter group, DB security /// group, DB snapshot, DB cluster snapshot group, or RDS Proxy can be obtained by providing /// the name as a parameter. /// /// /// /// For more information on working with events, see Monitoring /// Amazon RDS events in the Amazon RDS User Guide and Monitoring /// Amazon Aurora events in the Amazon Aurora User Guide. /// /// /// /// By default, RDS returns events that were generated in the past hour. /// /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEvents service method, as returned by RDS. /// REST API Reference for DescribeEvents Operation public virtual Task DescribeEventsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeEventsAsync(new DescribeEventsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeEvents service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEvents service method, as returned by RDS. /// REST API Reference for DescribeEvents Operation public virtual Task DescribeEventsAsync(DescribeEventsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEventSubscriptions internal virtual DescribeEventSubscriptionsResponse DescribeEventSubscriptions() { return DescribeEventSubscriptions(new DescribeEventSubscriptionsRequest()); } internal virtual DescribeEventSubscriptionsResponse DescribeEventSubscriptions(DescribeEventSubscriptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventSubscriptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventSubscriptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Lists all the subscription descriptions for a customer account. The description for /// a subscription includes SubscriptionName, SNSTopicARN, CustomerID, /// SourceType, SourceID, CreationTime, and Status. /// /// /// /// If you specify a SubscriptionName, lists the description for that subscription. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEventSubscriptions service method, as returned by RDS. /// /// The subscription name does not exist. /// /// REST API Reference for DescribeEventSubscriptions Operation public virtual Task DescribeEventSubscriptionsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeEventSubscriptionsAsync(new DescribeEventSubscriptionsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeEventSubscriptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEventSubscriptions service method, as returned by RDS. /// /// The subscription name does not exist. /// /// REST API Reference for DescribeEventSubscriptions Operation public virtual Task DescribeEventSubscriptionsAsync(DescribeEventSubscriptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventSubscriptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventSubscriptionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeExportTasks internal virtual DescribeExportTasksResponse DescribeExportTasks(DescribeExportTasksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeExportTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeExportTasksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about a snapshot or cluster export to Amazon S3. This API operation /// supports pagination. ///

/// Container for the necessary parameters to execute the DescribeExportTasks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeExportTasks service method, as returned by RDS. /// /// The export task doesn't exist. /// /// REST API Reference for DescribeExportTasks Operation public virtual Task DescribeExportTasksAsync(DescribeExportTasksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeExportTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeExportTasksResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeGlobalClusters internal virtual DescribeGlobalClustersResponse DescribeGlobalClusters(DescribeGlobalClustersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeGlobalClustersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeGlobalClustersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about Aurora global database clusters. This API supports pagination. /// /// /// /// For more information on Amazon Aurora, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// This action only applies to Aurora DB clusters. /// /// ///

/// Container for the necessary parameters to execute the DescribeGlobalClusters service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeGlobalClusters service method, as returned by RDS. /// /// The GlobalClusterIdentifier doesn't refer to an existing global database /// cluster. /// /// REST API Reference for DescribeGlobalClusters Operation public virtual Task DescribeGlobalClustersAsync(DescribeGlobalClustersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeGlobalClustersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeGlobalClustersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeOptionGroupOptions internal virtual DescribeOptionGroupOptionsResponse DescribeOptionGroupOptions(DescribeOptionGroupOptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeOptionGroupOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeOptionGroupOptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes all available options. ///

/// Container for the necessary parameters to execute the DescribeOptionGroupOptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeOptionGroupOptions service method, as returned by RDS. /// REST API Reference for DescribeOptionGroupOptions Operation public virtual Task DescribeOptionGroupOptionsAsync(DescribeOptionGroupOptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeOptionGroupOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeOptionGroupOptionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeOptionGroups internal virtual DescribeOptionGroupsResponse DescribeOptionGroups() { return DescribeOptionGroups(new DescribeOptionGroupsRequest()); } internal virtual DescribeOptionGroupsResponse DescribeOptionGroups(DescribeOptionGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeOptionGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeOptionGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes the available option groups. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeOptionGroups service method, as returned by RDS. /// /// The specified option group could not be found. /// /// REST API Reference for DescribeOptionGroups Operation public virtual Task DescribeOptionGroupsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeOptionGroupsAsync(new DescribeOptionGroupsRequest(), cancellationToken); } ///

/// Describes the available option groups. ///

/// Container for the necessary parameters to execute the DescribeOptionGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeOptionGroups service method, as returned by RDS. /// /// The specified option group could not be found. /// /// REST API Reference for DescribeOptionGroups Operation public virtual Task DescribeOptionGroupsAsync(DescribeOptionGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeOptionGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeOptionGroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeOrderableDBInstanceOptions internal virtual DescribeOrderableDBInstanceOptionsResponse DescribeOrderableDBInstanceOptions(DescribeOrderableDBInstanceOptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeOrderableDBInstanceOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeOrderableDBInstanceOptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of orderable DB instance options for the specified DB engine, DB engine /// version, and DB instance class. ///

/// Container for the necessary parameters to execute the DescribeOrderableDBInstanceOptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeOrderableDBInstanceOptions service method, as returned by RDS. /// REST API Reference for DescribeOrderableDBInstanceOptions Operation public virtual Task DescribeOrderableDBInstanceOptionsAsync(DescribeOrderableDBInstanceOptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeOrderableDBInstanceOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeOrderableDBInstanceOptionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribePendingMaintenanceActions internal virtual DescribePendingMaintenanceActionsResponse DescribePendingMaintenanceActions(DescribePendingMaintenanceActionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePendingMaintenanceActionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePendingMaintenanceActionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of resources (for example, DB instances) that have at least one pending /// maintenance action. ///

/// Container for the necessary parameters to execute the DescribePendingMaintenanceActions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribePendingMaintenanceActions service method, as returned by RDS. /// /// The specified resource ID was not found. /// /// REST API Reference for DescribePendingMaintenanceActions Operation public virtual Task DescribePendingMaintenanceActionsAsync(DescribePendingMaintenanceActionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePendingMaintenanceActionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePendingMaintenanceActionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeReservedDBInstances internal virtual DescribeReservedDBInstancesResponse DescribeReservedDBInstances() { return DescribeReservedDBInstances(new DescribeReservedDBInstancesRequest()); } internal virtual DescribeReservedDBInstancesResponse DescribeReservedDBInstances(DescribeReservedDBInstancesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedDBInstancesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedDBInstancesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about reserved DB instances for this account, or about a specified /// reserved DB instance. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedDBInstances service method, as returned by RDS. /// /// The specified reserved DB Instance not found. /// /// REST API Reference for DescribeReservedDBInstances Operation public virtual Task DescribeReservedDBInstancesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeReservedDBInstancesAsync(new DescribeReservedDBInstancesRequest(), cancellationToken); } ///

/// Returns information about reserved DB instances for this account, or about a specified /// reserved DB instance. ///

/// Container for the necessary parameters to execute the DescribeReservedDBInstances service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedDBInstances service method, as returned by RDS. /// /// The specified reserved DB Instance not found. /// /// REST API Reference for DescribeReservedDBInstances Operation public virtual Task DescribeReservedDBInstancesAsync(DescribeReservedDBInstancesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedDBInstancesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedDBInstancesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeReservedDBInstancesOfferings internal virtual DescribeReservedDBInstancesOfferingsResponse DescribeReservedDBInstancesOfferings() { return DescribeReservedDBInstancesOfferings(new DescribeReservedDBInstancesOfferingsRequest()); } internal virtual DescribeReservedDBInstancesOfferingsResponse DescribeReservedDBInstancesOfferings(DescribeReservedDBInstancesOfferingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedDBInstancesOfferingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedDBInstancesOfferingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Lists available reserved DB instance offerings. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedDBInstancesOfferings service method, as returned by RDS. /// /// Specified offering does not exist. /// /// REST API Reference for DescribeReservedDBInstancesOfferings Operation public virtual Task DescribeReservedDBInstancesOfferingsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeReservedDBInstancesOfferingsAsync(new DescribeReservedDBInstancesOfferingsRequest(), cancellationToken); } ///

/// Lists available reserved DB instance offerings. ///

/// Container for the necessary parameters to execute the DescribeReservedDBInstancesOfferings service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedDBInstancesOfferings service method, as returned by RDS. /// /// Specified offering does not exist. /// /// REST API Reference for DescribeReservedDBInstancesOfferings Operation public virtual Task DescribeReservedDBInstancesOfferingsAsync(DescribeReservedDBInstancesOfferingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedDBInstancesOfferingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedDBInstancesOfferingsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeSourceRegions internal virtual DescribeSourceRegionsResponse DescribeSourceRegions(DescribeSourceRegionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSourceRegionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSourceRegionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of the source Amazon Web Services Regions where the current Amazon /// Web Services Region can create a read replica, copy a DB snapshot from, or replicate /// automated backups from. /// /// /// /// Use this operation to determine whether cross-Region features are supported between /// other Regions and your current Region. This operation supports pagination. /// /// /// /// To return information about the Regions that are enabled for your account, or all /// Regions, use the EC2 operation DescribeRegions. For more information, /// see /// DescribeRegions in the Amazon EC2 API Reference. /// ///

/// Container for the necessary parameters to execute the DescribeSourceRegions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSourceRegions service method, as returned by RDS. /// REST API Reference for DescribeSourceRegions Operation public virtual Task DescribeSourceRegionsAsync(DescribeSourceRegionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSourceRegionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSourceRegionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeValidDBInstanceModifications internal virtual DescribeValidDBInstanceModificationsResponse DescribeValidDBInstanceModifications(DescribeValidDBInstanceModificationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeValidDBInstanceModificationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeValidDBInstanceModificationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// You can call DescribeValidDBInstanceModifications to learn what modifications /// you can make to your DB instance. You can use this information when you call ModifyDBInstance. /// /// /// /// This command doesn't apply to RDS Custom. /// ///

/// Container for the necessary parameters to execute the DescribeValidDBInstanceModifications service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeValidDBInstanceModifications service method, as returned by RDS. /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// The DB instance isn't in a valid state. /// /// REST API Reference for DescribeValidDBInstanceModifications Operation public virtual Task DescribeValidDBInstanceModificationsAsync(DescribeValidDBInstanceModificationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeValidDBInstanceModificationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeValidDBInstanceModificationsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DownloadDBLogFilePortion internal virtual DownloadDBLogFilePortionResponse DownloadDBLogFilePortion(DownloadDBLogFilePortionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DownloadDBLogFilePortionRequestMarshaller.Instance; options.ResponseUnmarshaller = DownloadDBLogFilePortionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Downloads all or a portion of the specified log file, up to 1 MB in size. /// /// /// /// This command doesn't apply to RDS Custom. /// ///

/// Container for the necessary parameters to execute the DownloadDBLogFilePortion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DownloadDBLogFilePortion service method, as returned by RDS. /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// LogFileName doesn't refer to an existing DB log file. /// /// REST API Reference for DownloadDBLogFilePortion Operation public virtual Task DownloadDBLogFilePortionAsync(DownloadDBLogFilePortionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DownloadDBLogFilePortionRequestMarshaller.Instance; options.ResponseUnmarshaller = DownloadDBLogFilePortionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region FailoverDBCluster internal virtual FailoverDBClusterResponse FailoverDBCluster(FailoverDBClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = FailoverDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = FailoverDBClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Forces a failover for a DB cluster. /// /// /// /// For an Aurora DB cluster, failover for a DB cluster promotes one of the Aurora Replicas /// (read-only instances) in the DB cluster to be the primary DB instance (the cluster /// writer). /// /// /// /// For a Multi-AZ DB cluster, failover for a DB cluster promotes one of the readable /// standby DB instances (read-only instances) in the DB cluster to be the primary DB /// instance (the cluster writer). /// /// /// /// An Amazon Aurora DB cluster automatically fails over to an Aurora Replica, if one /// exists, when the primary DB instance fails. A Multi-AZ DB cluster automatically fails /// over to a readable standby DB instance when the primary DB instance fails. /// /// /// /// To simulate a failure of a primary instance for testing, you can force a failover. /// Because each instance in a DB cluster has its own endpoint address, make sure to clean /// up and re-establish any existing connections that use those endpoint addresses when /// the failover is complete. /// /// /// /// For more information on Amazon Aurora DB clusters, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the FailoverDBCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the FailoverDBCluster service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB instance isn't in a valid state. /// /// REST API Reference for FailoverDBCluster Operation public virtual Task FailoverDBClusterAsync(FailoverDBClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = FailoverDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = FailoverDBClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region FailoverGlobalCluster internal virtual FailoverGlobalClusterResponse FailoverGlobalCluster(FailoverGlobalClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = FailoverGlobalClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = FailoverGlobalClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the failover process for an Aurora global database (GlobalCluster). /// /// /// /// A failover for an Aurora global database promotes one of secondary read-only DB clusters /// to be the primary DB cluster and demotes the primary DB cluster to being a secondary /// (read-only) DB cluster. In other words, the role of the current primary DB cluster /// and the selected (target) DB cluster are switched. The selected secondary DB cluster /// assumes full read/write capabilities for the Aurora global database. /// /// /// /// For more information about failing over an Amazon Aurora global database, see Managed /// planned failover for Amazon Aurora global databases in the Amazon Aurora User /// Guide. /// /// /// /// This action applies to GlobalCluster (Aurora global databases) only. Use this /// action only on healthy Aurora global databases with running Aurora DB clusters and /// no Region-wide outages, to test disaster recovery scenarios or to reconfigure your /// Aurora global database topology. /// /// ///

/// Container for the necessary parameters to execute the FailoverGlobalCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the FailoverGlobalCluster service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// The GlobalClusterIdentifier doesn't refer to an existing global database /// cluster. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The global cluster is in an invalid state and can't perform the requested operation. /// /// REST API Reference for FailoverGlobalCluster Operation public virtual Task FailoverGlobalClusterAsync(FailoverGlobalClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = FailoverGlobalClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = FailoverGlobalClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListTagsForResource internal virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Lists all tags on an Amazon RDS resource. /// /// /// /// For an overview on tagging an Amazon RDS resource, see Tagging /// Amazon RDS Resources in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListTagsForResource service method, as returned by RDS. /// /// BlueGreenDeploymentIdentifier doesn't refer to an existing blue/green /// deployment. /// /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The specified target group isn't available for a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// DBSnapshotIdentifier doesn't refer to an existing DB snapshot. /// /// REST API Reference for ListTagsForResource Operation public virtual Task ListTagsForResourceAsync(ListTagsForResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyActivityStream internal virtual ModifyActivityStreamResponse ModifyActivityStream(ModifyActivityStreamRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyActivityStreamRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyActivityStreamResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Changes the audit policy state of a database activity stream to either locked (default) /// or unlocked. A locked policy is read-only, whereas an unlocked policy is read/write. /// If your activity stream is started and locked, you can unlock it, customize your audit /// policy, and then lock your activity stream. Restarting the activity stream isn't required. /// For more information, see /// Modifying a database activity stream in the Amazon RDS User Guide. /// /// /// /// This operation is supported for RDS for Oracle and Microsoft SQL Server. /// ///

/// Container for the necessary parameters to execute the ModifyActivityStream service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyActivityStream service method, as returned by RDS. /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// The DB instance isn't in a valid state. /// /// /// The specified resource ID was not found. /// /// REST API Reference for ModifyActivityStream Operation public virtual Task ModifyActivityStreamAsync(ModifyActivityStreamRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyActivityStreamRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyActivityStreamResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyCertificates internal virtual ModifyCertificatesResponse ModifyCertificates(ModifyCertificatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyCertificatesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Override the system-default Secure Sockets Layer/Transport Layer Security (SSL/TLS) /// certificate for Amazon RDS for new DB instances, or remove the override. /// /// /// /// By using this operation, you can specify an RDS-approved SSL/TLS certificate for new /// DB instances that is different from the default certificate provided by RDS. You can /// also use this operation to remove the override, so that new DB instances use the default /// certificate provided by RDS. /// /// /// /// You might need to override the default certificate in the following situations: /// ///

/// /// You already migrated your applications to support the latest certificate authority /// (CA) certificate, but the new CA certificate is not yet the RDS default CA certificate /// for the specified Amazon Web Services Region. /// ///
/// /// RDS has already moved to a new default CA certificate for the specified Amazon Web /// Services Region, but you are still in the process of supporting the new CA certificate. /// In this case, you temporarily need additional time to finish your application changes. /// ///

/// /// For more information about rotating your SSL/TLS certificate for RDS DB engines, see /// /// Rotating Your SSL/TLS Certificate in the Amazon RDS User Guide. /// /// /// /// For more information about rotating your SSL/TLS certificate for Aurora DB engines, /// see /// Rotating Your SSL/TLS Certificate in the Amazon Aurora User Guide. /// ///

/// Container for the necessary parameters to execute the ModifyCertificates service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyCertificates service method, as returned by RDS. /// /// CertificateIdentifier doesn't refer to an existing certificate. /// /// REST API Reference for ModifyCertificates Operation public virtual Task ModifyCertificatesAsync(ModifyCertificatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyCertificatesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyCurrentDBClusterCapacity internal virtual ModifyCurrentDBClusterCapacityResponse ModifyCurrentDBClusterCapacity(ModifyCurrentDBClusterCapacityRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyCurrentDBClusterCapacityRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyCurrentDBClusterCapacityResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Set the capacity of an Aurora Serverless v1 DB cluster to a specific value. /// /// /// /// Aurora Serverless v1 scales seamlessly based on the workload on the DB cluster. In /// some cases, the capacity might not scale fast enough to meet a sudden change in workload, /// such as a large number of new transactions. Call ModifyCurrentDBClusterCapacity /// to set the capacity explicitly. /// /// /// /// After this call sets the DB cluster capacity, Aurora Serverless v1 can automatically /// scale the DB cluster based on the cooldown period for scaling up and the cooldown /// period for scaling down. /// /// /// /// For more information about Aurora Serverless v1, see Using /// Amazon Aurora Serverless v1 in the Amazon Aurora User Guide. /// /// /// /// If you call ModifyCurrentDBClusterCapacity with the default TimeoutAction, /// connections that prevent Aurora Serverless v1 from finding a scaling point might be /// dropped. For more information about scaling points, see /// Autoscaling for Aurora Serverless v1 in the Amazon Aurora User Guide. /// /// /// /// This action only applies to Aurora Serverless v1 DB clusters. /// /// ///

/// Container for the necessary parameters to execute the ModifyCurrentDBClusterCapacity service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyCurrentDBClusterCapacity service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// Capacity isn't a valid Aurora Serverless DB cluster capacity. Valid /// capacity values are 2, 4, 8, 16, /// 32, 64, 128, and 256. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// REST API Reference for ModifyCurrentDBClusterCapacity Operation public virtual Task ModifyCurrentDBClusterCapacityAsync(ModifyCurrentDBClusterCapacityRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyCurrentDBClusterCapacityRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyCurrentDBClusterCapacityResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyCustomDBEngineVersion internal virtual ModifyCustomDBEngineVersionResponse ModifyCustomDBEngineVersion(ModifyCustomDBEngineVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyCustomDBEngineVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyCustomDBEngineVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies the status of a custom engine version (CEV). You can find CEVs to modify /// by calling DescribeDBEngineVersions. /// /// /// /// The MediaImport service that imports files from Amazon S3 to create CEVs isn't integrated /// with Amazon Web Services CloudTrail. If you turn on data logging for Amazon RDS in /// CloudTrail, calls to the ModifyCustomDbEngineVersion event aren't logged. /// However, you might see calls from the API gateway that accesses your Amazon S3 bucket. /// These calls originate from the MediaImport service for the ModifyCustomDbEngineVersion /// event. /// /// /// /// For more information, see Modifying /// CEV status in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the ModifyCustomDBEngineVersion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyCustomDBEngineVersion service method, as returned by RDS. /// /// The specified CEV was not found. /// /// /// You can't delete the CEV. /// /// REST API Reference for ModifyCustomDBEngineVersion Operation public virtual Task ModifyCustomDBEngineVersionAsync(ModifyCustomDBEngineVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyCustomDBEngineVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyCustomDBEngineVersionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyDBCluster internal virtual ModifyDBClusterResponse ModifyDBCluster(ModifyDBClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies the settings of an Amazon Aurora DB cluster or a Multi-AZ DB cluster. You /// can change one or more settings by specifying these parameters and the new values /// in the request. /// /// /// /// For more information on Amazon Aurora DB clusters, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the ModifyDBCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyDBCluster service method, as returned by RDS. /// /// The user already has a DB cluster with the given identifier. /// /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// DBClusterParameterGroupName doesn't refer to an existing DB cluster /// parameter group. /// /// /// The user already has a DB instance with the given identifier. /// /// /// DBSubnetGroupName doesn't refer to an existing DB subnet group. /// /// /// Domain doesn't refer to an existing Active Directory domain. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB instance isn't in a valid state. /// /// /// The state of the DB security group doesn't allow deletion. /// /// /// The DB subnet group cannot be deleted because it's in use. /// /// /// The requested subnet is invalid, or multiple subnets were requested that are not all /// in a common VPC. /// /// /// The DB subnet group doesn't cover all Availability Zones after it's created because /// of users' change. /// /// /// The request would result in the user exceeding the allowed amount of storage available /// across all DB instances. /// /// /// The aurora-iopt1 storage type isn't available, because you modified the /// DB cluster to use this storage type less than one month ago. /// /// REST API Reference for ModifyDBCluster Operation public virtual Task ModifyDBClusterAsync(ModifyDBClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyDBClusterEndpoint internal virtual ModifyDBClusterEndpointResponse ModifyDBClusterEndpoint(ModifyDBClusterEndpointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBClusterEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBClusterEndpointResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies the properties of an endpoint in an Amazon Aurora DB cluster. /// /// /// /// This action only applies to Aurora DB clusters. /// /// ///

/// Container for the necessary parameters to execute the ModifyDBClusterEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyDBClusterEndpoint service method, as returned by RDS. /// /// The specified custom endpoint doesn't exist. /// /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// The requested operation can't be performed on the endpoint while the endpoint is in /// this state. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB instance isn't in a valid state. /// /// REST API Reference for ModifyDBClusterEndpoint Operation public virtual Task ModifyDBClusterEndpointAsync(ModifyDBClusterEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBClusterEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBClusterEndpointResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyDBClusterParameterGroup internal virtual ModifyDBClusterParameterGroupResponse ModifyDBClusterParameterGroup(ModifyDBClusterParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBClusterParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies the parameters of a DB cluster parameter group. To modify more than one parameter, /// submit a list of the following: ParameterName, ParameterValue, /// and ApplyMethod. A maximum of 20 parameters can be modified in a single /// request. /// /// /// /// After you create a DB cluster parameter group, you should wait at least 5 minutes /// before creating your first DB cluster that uses that DB cluster parameter group as /// the default parameter group. This allows Amazon RDS to fully complete the create action /// before the parameter group is used as the default for a new DB cluster. This is especially /// important for parameters that are critical when creating the default database for /// a DB cluster, such as the character set for the default database defined by the character_set_database /// parameter. You can use the Parameter Groups option of the Amazon /// RDS console or the DescribeDBClusterParameters operation to verify /// that your DB cluster parameter group has been created or modified. /// /// /// /// If the modified DB cluster parameter group is used by an Aurora Serverless v1 cluster, /// Aurora applies the update immediately. The cluster restart might interrupt your workload. /// In that case, your application must reopen any connections and retry any transactions /// that were active when the parameter changes took effect. /// /// /// /// For more information on Amazon Aurora DB clusters, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the ModifyDBClusterParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyDBClusterParameterGroup service method, as returned by RDS. /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// The DB parameter group is in use or is in an invalid state. If you are attempting /// to delete the parameter group, you can't delete it when the parameter group is in /// this state. /// /// REST API Reference for ModifyDBClusterParameterGroup Operation public virtual Task ModifyDBClusterParameterGroupAsync(ModifyDBClusterParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBClusterParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyDBClusterSnapshotAttribute internal virtual ModifyDBClusterSnapshotAttributeResponse ModifyDBClusterSnapshotAttribute(ModifyDBClusterSnapshotAttributeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBClusterSnapshotAttributeRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBClusterSnapshotAttributeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Adds an attribute and values to, or removes an attribute and values from, a manual /// DB cluster snapshot. /// /// /// /// To share a manual DB cluster snapshot with other Amazon Web Services accounts, specify /// restore as the AttributeName and use the ValuesToAdd /// parameter to add a list of IDs of the Amazon Web Services accounts that are authorized /// to restore the manual DB cluster snapshot. Use the value all to make /// the manual DB cluster snapshot public, which means that it can be copied or restored /// by all Amazon Web Services accounts. /// /// /// /// Don't add the all value for any manual DB cluster snapshots that contain /// private information that you don't want available to all Amazon Web Services accounts. /// /// /// /// If a manual DB cluster snapshot is encrypted, it can be shared, but only by specifying /// a list of authorized Amazon Web Services account IDs for the ValuesToAdd /// parameter. You can't use all as a value for that parameter in this case. /// /// /// /// To view which Amazon Web Services accounts have access to copy or restore a manual /// DB cluster snapshot, or whether a manual DB cluster snapshot is public or private, /// use the DescribeDBClusterSnapshotAttributes API operation. The accounts are /// returned as values for the restore attribute. /// ///

/// Container for the necessary parameters to execute the ModifyDBClusterSnapshotAttribute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyDBClusterSnapshotAttribute service method, as returned by RDS. /// /// DBClusterSnapshotIdentifier doesn't refer to an existing DB cluster /// snapshot. /// /// /// The supplied value isn't a valid DB cluster snapshot state. /// /// /// You have exceeded the maximum number of accounts that you can share a manual DB snapshot /// with. /// /// REST API Reference for ModifyDBClusterSnapshotAttribute Operation public virtual Task ModifyDBClusterSnapshotAttributeAsync(ModifyDBClusterSnapshotAttributeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBClusterSnapshotAttributeRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBClusterSnapshotAttributeResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyDBInstance internal virtual ModifyDBInstanceResponse ModifyDBInstance(ModifyDBInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies settings for a DB instance. You can change one or more database configuration /// parameters by specifying these parameters and the new values in the request. To learn /// what modifications you can make to your DB instance, call DescribeValidDBInstanceModifications /// before you call ModifyDBInstance. ///

/// Container for the necessary parameters to execute the ModifyDBInstance service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyDBInstance service method, as returned by RDS. /// /// The specified CIDR IP range or Amazon EC2 security group might not be authorized for /// the specified DB security group. /// /// /// /// Or, RDS might not be authorized to perform necessary actions using IAM on your behalf. /// /// /// /// /// /// /// CertificateIdentifier doesn't refer to an existing certificate. /// /// /// The user already has a DB instance with the given identifier. /// /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// DBSecurityGroupName doesn't refer to an existing DB security group. /// /// /// The DB upgrade failed because a resource the DB depends on can't be modified. /// /// /// Domain doesn't refer to an existing Active Directory domain. /// /// /// The specified DB instance class isn't available in the specified Availability Zone. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB instance isn't in a valid state. /// /// /// The state of the DB security group doesn't allow deletion. /// /// /// The DB subnet group doesn't cover all Availability Zones after it's created because /// of users' change. /// /// /// An error occurred accessing an Amazon Web Services KMS key. /// /// /// The network type is invalid for the DB instance. Valid nework type values are IPV4 /// and DUAL. /// /// /// The specified option group could not be found. /// /// /// Provisioned IOPS not available in the specified Availability Zone. /// /// /// The request would result in the user exceeding the allowed amount of storage available /// across all DB instances. /// /// /// The specified StorageType can't be associated with the DB instance. /// /// REST API Reference for ModifyDBInstance Operation public virtual Task ModifyDBInstanceAsync(ModifyDBInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBInstanceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyDBParameterGroup internal virtual ModifyDBParameterGroupResponse ModifyDBParameterGroup(ModifyDBParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies the parameters of a DB parameter group. To modify more than one parameter, /// submit a list of the following: ParameterName, ParameterValue, /// and ApplyMethod. A maximum of 20 parameters can be modified in a single /// request. /// /// /// /// After you modify a DB parameter group, you should wait at least 5 minutes before creating /// your first DB instance that uses that DB parameter group as the default parameter /// group. This allows Amazon RDS to fully complete the modify action before the parameter /// group is used as the default for a new DB instance. This is especially important for /// parameters that are critical when creating the default database for a DB instance, /// such as the character set for the default database defined by the character_set_database /// parameter. You can use the Parameter Groups option of the Amazon /// RDS console or the DescribeDBParameters command to verify that your DB /// parameter group has been created or modified. /// /// ///

/// Container for the necessary parameters to execute the ModifyDBParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyDBParameterGroup service method, as returned by RDS. /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// The DB parameter group is in use or is in an invalid state. If you are attempting /// to delete the parameter group, you can't delete it when the parameter group is in /// this state. /// /// REST API Reference for ModifyDBParameterGroup Operation public virtual Task ModifyDBParameterGroupAsync(ModifyDBParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyDBProxy internal virtual ModifyDBProxyResponse ModifyDBProxy(ModifyDBProxyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBProxyRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBProxyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Changes the settings for an existing DB proxy. ///

/// Container for the necessary parameters to execute the ModifyDBProxy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyDBProxy service method, as returned by RDS. /// /// The specified proxy name must be unique for all proxies owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The requested operation can't be performed while the proxy is in this state. /// /// REST API Reference for ModifyDBProxy Operation public virtual Task ModifyDBProxyAsync(ModifyDBProxyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBProxyRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBProxyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyDBProxyEndpoint internal virtual ModifyDBProxyEndpointResponse ModifyDBProxyEndpoint(ModifyDBProxyEndpointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBProxyEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBProxyEndpointResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Changes the settings for an existing DB proxy endpoint. ///

/// Container for the necessary parameters to execute the ModifyDBProxyEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyDBProxyEndpoint service method, as returned by RDS. /// /// The specified DB proxy endpoint name must be unique for all DB proxy endpoints owned /// by your Amazon Web Services account in the specified Amazon Web Services Region. /// /// /// The DB proxy endpoint doesn't exist. /// /// /// You can't perform this operation while the DB proxy endpoint is in a particular state. /// /// /// The requested operation can't be performed while the proxy is in this state. /// /// REST API Reference for ModifyDBProxyEndpoint Operation public virtual Task ModifyDBProxyEndpointAsync(ModifyDBProxyEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBProxyEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBProxyEndpointResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyDBProxyTargetGroup internal virtual ModifyDBProxyTargetGroupResponse ModifyDBProxyTargetGroup(ModifyDBProxyTargetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBProxyTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBProxyTargetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies the properties of a DBProxyTargetGroup. ///

/// Container for the necessary parameters to execute the ModifyDBProxyTargetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyDBProxyTargetGroup service method, as returned by RDS. /// /// The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The specified target group isn't available for a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The requested operation can't be performed while the proxy is in this state. /// /// REST API Reference for ModifyDBProxyTargetGroup Operation public virtual Task ModifyDBProxyTargetGroupAsync(ModifyDBProxyTargetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBProxyTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBProxyTargetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyDBSnapshot internal virtual ModifyDBSnapshotResponse ModifyDBSnapshot(ModifyDBSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Updates a manual DB snapshot with a new engine version. The snapshot can be encrypted /// or unencrypted, but not shared or public. /// /// /// /// Amazon RDS supports upgrading DB snapshots for MySQL, PostgreSQL, and Oracle. This /// command doesn't apply to RDS Custom. /// ///

/// Container for the necessary parameters to execute the ModifyDBSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyDBSnapshot service method, as returned by RDS. /// /// DBSnapshotIdentifier doesn't refer to an existing DB snapshot. /// /// REST API Reference for ModifyDBSnapshot Operation public virtual Task ModifyDBSnapshotAsync(ModifyDBSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyDBSnapshotAttribute internal virtual ModifyDBSnapshotAttributeResponse ModifyDBSnapshotAttribute(ModifyDBSnapshotAttributeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBSnapshotAttributeRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBSnapshotAttributeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Adds an attribute and values to, or removes an attribute and values from, a manual /// DB snapshot. /// /// /// /// To share a manual DB snapshot with other Amazon Web Services accounts, specify restore /// as the AttributeName and use the ValuesToAdd parameter to /// add a list of IDs of the Amazon Web Services accounts that are authorized to restore /// the manual DB snapshot. Uses the value all to make the manual DB snapshot /// public, which means it can be copied or restored by all Amazon Web Services accounts. /// /// /// /// Don't add the all value for any manual DB snapshots that contain private /// information that you don't want available to all Amazon Web Services accounts. /// /// /// /// If the manual DB snapshot is encrypted, it can be shared, but only by specifying a /// list of authorized Amazon Web Services account IDs for the ValuesToAdd /// parameter. You can't use all as a value for that parameter in this case. /// /// /// /// To view which Amazon Web Services accounts have access to copy or restore a manual /// DB snapshot, or whether a manual DB snapshot public or private, use the DescribeDBSnapshotAttributes /// API operation. The accounts are returned as values for the restore attribute. /// ///

/// Container for the necessary parameters to execute the ModifyDBSnapshotAttribute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyDBSnapshotAttribute service method, as returned by RDS. /// /// DBSnapshotIdentifier doesn't refer to an existing DB snapshot. /// /// /// The state of the DB snapshot doesn't allow deletion. /// /// /// You have exceeded the maximum number of accounts that you can share a manual DB snapshot /// with. /// /// REST API Reference for ModifyDBSnapshotAttribute Operation public virtual Task ModifyDBSnapshotAttributeAsync(ModifyDBSnapshotAttributeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBSnapshotAttributeRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBSnapshotAttributeResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyDBSubnetGroup internal virtual ModifyDBSubnetGroupResponse ModifyDBSubnetGroup(ModifyDBSubnetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBSubnetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies an existing DB subnet group. DB subnet groups must contain at least one subnet /// in at least two AZs in the Amazon Web Services Region. ///

/// Container for the necessary parameters to execute the ModifyDBSubnetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyDBSubnetGroup service method, as returned by RDS. /// /// Subnets in the DB subnet group should cover at least two Availability Zones unless /// there is only one Availability Zone. /// /// /// DBSubnetGroupName doesn't refer to an existing DB subnet group. /// /// /// The request would result in the user exceeding the allowed number of subnets in a /// DB subnet groups. /// /// /// The requested subnet is invalid, or multiple subnets were requested that are not all /// in a common VPC. /// /// /// The DB subnet is already in use in the Availability Zone. /// /// REST API Reference for ModifyDBSubnetGroup Operation public virtual Task ModifyDBSubnetGroupAsync(ModifyDBSubnetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDBSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDBSubnetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyEventSubscription internal virtual ModifyEventSubscriptionResponse ModifyEventSubscription(ModifyEventSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyEventSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyEventSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies an existing RDS event notification subscription. You can't modify the source /// identifiers using this call. To change source identifiers for a subscription, use /// the AddSourceIdentifierToSubscription and RemoveSourceIdentifierFromSubscription /// calls. /// /// /// /// You can see a list of the event categories for a given source type (SourceType) /// in Events /// in the Amazon RDS User Guide or by using the DescribeEventCategories /// operation. /// ///

/// Container for the necessary parameters to execute the ModifyEventSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyEventSubscription service method, as returned by RDS. /// /// You have reached the maximum number of event subscriptions. /// /// /// SNS has responded that there is a problem with the SNS topic specified. /// /// /// You do not have permission to publish to the SNS topic ARN. /// /// /// The SNS topic ARN does not exist. /// /// /// The supplied category does not exist. /// /// /// The subscription name does not exist. /// /// REST API Reference for ModifyEventSubscription Operation public virtual Task ModifyEventSubscriptionAsync(ModifyEventSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyEventSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyEventSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyGlobalCluster internal virtual ModifyGlobalClusterResponse ModifyGlobalCluster(ModifyGlobalClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyGlobalClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyGlobalClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies a setting for an Amazon Aurora global cluster. You can change one or more /// database configuration parameters by specifying these parameters and the new values /// in the request. For more information on Amazon Aurora, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// This operation only applies to Aurora global database clusters. /// /// ///

/// Container for the necessary parameters to execute the ModifyGlobalCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyGlobalCluster service method, as returned by RDS. /// /// The GlobalClusterIdentifier doesn't refer to an existing global database /// cluster. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB instance isn't in a valid state. /// /// /// The global cluster is in an invalid state and can't perform the requested operation. /// /// REST API Reference for ModifyGlobalCluster Operation public virtual Task ModifyGlobalClusterAsync(ModifyGlobalClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyGlobalClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyGlobalClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyOptionGroup internal virtual ModifyOptionGroupResponse ModifyOptionGroup(ModifyOptionGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyOptionGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyOptionGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies an existing option group. ///

/// Container for the necessary parameters to execute the ModifyOptionGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyOptionGroup service method, as returned by RDS. /// /// The option group isn't in the available state. /// /// /// The specified option group could not be found. /// /// REST API Reference for ModifyOptionGroup Operation public virtual Task ModifyOptionGroupAsync(ModifyOptionGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyOptionGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyOptionGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region PromoteReadReplica internal virtual PromoteReadReplicaResponse PromoteReadReplica(PromoteReadReplicaRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PromoteReadReplicaRequestMarshaller.Instance; options.ResponseUnmarshaller = PromoteReadReplicaResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Promotes a read replica DB instance to a standalone DB instance. /// ///

/// /// Backup duration is a function of the amount of changes to the database since the previous /// backup. If you plan to promote a read replica to a standalone instance, we recommend /// that you enable backups and complete at least one backup prior to promotion. In addition, /// a read replica cannot be promoted to a standalone instance when it is in the backing-up /// status. If you have enabled backups on your read replica, configure the automated /// backup window so that daily backups do not interfere with read replica promotion. /// ///
/// /// This command doesn't apply to Aurora MySQL, Aurora PostgreSQL, or RDS Custom. /// ///

///

/// Container for the necessary parameters to execute the PromoteReadReplica service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the PromoteReadReplica service method, as returned by RDS. /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// The DB instance isn't in a valid state. /// /// REST API Reference for PromoteReadReplica Operation public virtual Task PromoteReadReplicaAsync(PromoteReadReplicaRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = PromoteReadReplicaRequestMarshaller.Instance; options.ResponseUnmarshaller = PromoteReadReplicaResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region PromoteReadReplicaDBCluster internal virtual PromoteReadReplicaDBClusterResponse PromoteReadReplicaDBCluster(PromoteReadReplicaDBClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PromoteReadReplicaDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = PromoteReadReplicaDBClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Promotes a read replica DB cluster to a standalone DB cluster. ///

/// Container for the necessary parameters to execute the PromoteReadReplicaDBCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the PromoteReadReplicaDBCluster service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// REST API Reference for PromoteReadReplicaDBCluster Operation public virtual Task PromoteReadReplicaDBClusterAsync(PromoteReadReplicaDBClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = PromoteReadReplicaDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = PromoteReadReplicaDBClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region PurchaseReservedDBInstancesOffering internal virtual PurchaseReservedDBInstancesOfferingResponse PurchaseReservedDBInstancesOffering(PurchaseReservedDBInstancesOfferingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PurchaseReservedDBInstancesOfferingRequestMarshaller.Instance; options.ResponseUnmarshaller = PurchaseReservedDBInstancesOfferingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Purchases a reserved DB instance offering. ///

/// Container for the necessary parameters to execute the PurchaseReservedDBInstancesOffering service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the PurchaseReservedDBInstancesOffering service method, as returned by RDS. /// /// User already has a reservation with the given identifier. /// /// /// Request would exceed the user's DB Instance quota. /// /// /// Specified offering does not exist. /// /// REST API Reference for PurchaseReservedDBInstancesOffering Operation public virtual Task PurchaseReservedDBInstancesOfferingAsync(PurchaseReservedDBInstancesOfferingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = PurchaseReservedDBInstancesOfferingRequestMarshaller.Instance; options.ResponseUnmarshaller = PurchaseReservedDBInstancesOfferingResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RebootDBCluster internal virtual RebootDBClusterResponse RebootDBCluster(RebootDBClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RebootDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = RebootDBClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// You might need to reboot your DB cluster, usually for maintenance reasons. For example, /// if you make certain modifications, or if you change the DB cluster parameter group /// associated with the DB cluster, reboot the DB cluster for the changes to take effect. /// /// /// /// Rebooting a DB cluster restarts the database engine service. Rebooting a DB cluster /// results in a momentary outage, during which the DB cluster status is set to rebooting. /// /// /// /// Use this operation only for a non-Aurora Multi-AZ DB cluster. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the RebootDBCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RebootDBCluster service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB instance isn't in a valid state. /// /// REST API Reference for RebootDBCluster Operation public virtual Task RebootDBClusterAsync(RebootDBClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RebootDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = RebootDBClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RebootDBInstance internal virtual RebootDBInstanceResponse RebootDBInstance(RebootDBInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RebootDBInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = RebootDBInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// You might need to reboot your DB instance, usually for maintenance reasons. For example, /// if you make certain modifications, or if you change the DB parameter group associated /// with the DB instance, you must reboot the instance for the changes to take effect. /// /// /// /// Rebooting a DB instance restarts the database engine service. Rebooting a DB instance /// results in a momentary outage, during which the DB instance status is set to rebooting. /// /// /// /// For more information about rebooting, see Rebooting /// a DB Instance in the Amazon RDS User Guide. /// /// /// /// This command doesn't apply to RDS Custom. /// /// /// /// If your DB instance is part of a Multi-AZ DB cluster, you can reboot the DB cluster /// with the RebootDBCluster operation. /// ///

/// Container for the necessary parameters to execute the RebootDBInstance service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RebootDBInstance service method, as returned by RDS. /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// The DB instance isn't in a valid state. /// /// REST API Reference for RebootDBInstance Operation public virtual Task RebootDBInstanceAsync(RebootDBInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RebootDBInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = RebootDBInstanceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RegisterDBProxyTargets internal virtual RegisterDBProxyTargetsResponse RegisterDBProxyTargets(RegisterDBProxyTargetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterDBProxyTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterDBProxyTargetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Associate one or more DBProxyTarget data structures with a DBProxyTargetGroup. ///

/// Container for the necessary parameters to execute the RegisterDBProxyTargets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RegisterDBProxyTargets service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The proxy is already associated with the specified RDS DB instance or Aurora DB cluster. /// /// /// The specified target group isn't available for a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The requested operation can't be performed because there aren't enough available IP /// addresses in the proxy's subnets. Add more CIDR blocks to the VPC or remove IP address /// that aren't required from the subnets. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB instance isn't in a valid state. /// /// /// The requested operation can't be performed while the proxy is in this state. /// /// REST API Reference for RegisterDBProxyTargets Operation public virtual Task RegisterDBProxyTargetsAsync(RegisterDBProxyTargetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterDBProxyTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterDBProxyTargetsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RemoveFromGlobalCluster internal virtual RemoveFromGlobalClusterResponse RemoveFromGlobalCluster(RemoveFromGlobalClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveFromGlobalClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveFromGlobalClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Detaches an Aurora secondary cluster from an Aurora global database cluster. The cluster /// becomes a standalone cluster with read-write capability instead of being read-only /// and receiving data from a primary cluster in a different Region. /// /// /// /// This action only applies to Aurora DB clusters. /// /// ///

/// Container for the necessary parameters to execute the RemoveFromGlobalCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RemoveFromGlobalCluster service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// The GlobalClusterIdentifier doesn't refer to an existing global database /// cluster. /// /// /// The global cluster is in an invalid state and can't perform the requested operation. /// /// REST API Reference for RemoveFromGlobalCluster Operation public virtual Task RemoveFromGlobalClusterAsync(RemoveFromGlobalClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveFromGlobalClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveFromGlobalClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RemoveRoleFromDBCluster internal virtual RemoveRoleFromDBClusterResponse RemoveRoleFromDBCluster(RemoveRoleFromDBClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveRoleFromDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveRoleFromDBClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Removes the asssociation of an Amazon Web Services Identity and Access Management /// (IAM) role from a DB cluster. /// /// /// /// For more information on Amazon Aurora DB clusters, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the RemoveRoleFromDBCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RemoveRoleFromDBCluster service method, as returned by RDS. /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// The specified IAM role Amazon Resource Name (ARN) isn't associated with the specified /// DB cluster. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// REST API Reference for RemoveRoleFromDBCluster Operation public virtual Task RemoveRoleFromDBClusterAsync(RemoveRoleFromDBClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveRoleFromDBClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveRoleFromDBClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RemoveRoleFromDBInstance internal virtual RemoveRoleFromDBInstanceResponse RemoveRoleFromDBInstance(RemoveRoleFromDBInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveRoleFromDBInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveRoleFromDBInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Disassociates an Amazon Web Services Identity and Access Management (IAM) role from /// a DB instance. ///

/// Container for the necessary parameters to execute the RemoveRoleFromDBInstance service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RemoveRoleFromDBInstance service method, as returned by RDS. /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// The specified RoleArn value doesn't match the specified feature for the /// DB instance. /// /// /// The DB instance isn't in a valid state. /// /// REST API Reference for RemoveRoleFromDBInstance Operation public virtual Task RemoveRoleFromDBInstanceAsync(RemoveRoleFromDBInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveRoleFromDBInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveRoleFromDBInstanceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RemoveSourceIdentifierFromSubscription internal virtual RemoveSourceIdentifierFromSubscriptionResponse RemoveSourceIdentifierFromSubscription(RemoveSourceIdentifierFromSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveSourceIdentifierFromSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveSourceIdentifierFromSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Removes a source identifier from an existing RDS event notification subscription. ///

/// Container for the necessary parameters to execute the RemoveSourceIdentifierFromSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RemoveSourceIdentifierFromSubscription service method, as returned by RDS. /// /// The requested source could not be found. /// /// /// The subscription name does not exist. /// /// REST API Reference for RemoveSourceIdentifierFromSubscription Operation public virtual Task RemoveSourceIdentifierFromSubscriptionAsync(RemoveSourceIdentifierFromSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveSourceIdentifierFromSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveSourceIdentifierFromSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RemoveTagsFromResource internal virtual RemoveTagsFromResourceResponse RemoveTagsFromResource(RemoveTagsFromResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveTagsFromResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveTagsFromResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Removes metadata tags from an Amazon RDS resource. /// /// /// /// For an overview on tagging an Amazon RDS resource, see Tagging /// Amazon RDS Resources in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the RemoveTagsFromResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RemoveTagsFromResource service method, as returned by RDS. /// /// BlueGreenDeploymentIdentifier doesn't refer to an existing blue/green /// deployment. /// /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// DBInstanceIdentifier doesn't refer to an existing DB instance. /// /// /// The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// The specified target group isn't available for a proxy owned by your Amazon Web Services /// account in the specified Amazon Web Services Region. /// /// /// DBSnapshotIdentifier doesn't refer to an existing DB snapshot. /// /// REST API Reference for RemoveTagsFromResource Operation public virtual Task RemoveTagsFromResourceAsync(RemoveTagsFromResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveTagsFromResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveTagsFromResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ResetDBClusterParameterGroup internal virtual ResetDBClusterParameterGroupResponse ResetDBClusterParameterGroup(ResetDBClusterParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ResetDBClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetDBClusterParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies the parameters of a DB cluster parameter group to the default value. To reset /// specific parameters submit a list of the following: ParameterName and /// ApplyMethod. To reset the entire DB cluster parameter group, specify /// the DBClusterParameterGroupName and ResetAllParameters parameters. /// /// /// /// When resetting the entire group, dynamic parameters are updated immediately and static /// parameters are set to pending-reboot to take effect on the next DB instance /// restart or RebootDBInstance request. You must call RebootDBInstance /// for every DB instance in your DB cluster that you want the updated static parameter /// to apply to. /// /// /// /// For more information on Amazon Aurora DB clusters, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the ResetDBClusterParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ResetDBClusterParameterGroup service method, as returned by RDS. /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// The DB parameter group is in use or is in an invalid state. If you are attempting /// to delete the parameter group, you can't delete it when the parameter group is in /// this state. /// /// REST API Reference for ResetDBClusterParameterGroup Operation public virtual Task ResetDBClusterParameterGroupAsync(ResetDBClusterParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ResetDBClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetDBClusterParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ResetDBParameterGroup internal virtual ResetDBParameterGroupResponse ResetDBParameterGroup(ResetDBParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ResetDBParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetDBParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies the parameters of a DB parameter group to the engine/system default value. /// To reset specific parameters, provide a list of the following: ParameterName /// and ApplyMethod. To reset the entire DB parameter group, specify the /// DBParameterGroup name and ResetAllParameters parameters. /// When resetting the entire group, dynamic parameters are updated immediately and static /// parameters are set to pending-reboot to take effect on the next DB instance /// restart or RebootDBInstance request. ///

/// Container for the necessary parameters to execute the ResetDBParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ResetDBParameterGroup service method, as returned by RDS. /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// The DB parameter group is in use or is in an invalid state. If you are attempting /// to delete the parameter group, you can't delete it when the parameter group is in /// this state. /// /// REST API Reference for ResetDBParameterGroup Operation public virtual Task ResetDBParameterGroupAsync(ResetDBParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ResetDBParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetDBParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RestoreDBClusterFromS3 internal virtual RestoreDBClusterFromS3Response RestoreDBClusterFromS3(RestoreDBClusterFromS3Request request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreDBClusterFromS3RequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreDBClusterFromS3ResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates an Amazon Aurora DB cluster from MySQL data stored in an Amazon S3 bucket. /// Amazon RDS must be authorized to access the Amazon S3 bucket and the data must be /// created using the Percona XtraBackup utility as described in /// Migrating Data from MySQL by Using an Amazon S3 Bucket in the Amazon Aurora /// User Guide. /// /// /// /// This action only restores the DB cluster, not the DB instances for that DB cluster. /// You must invoke the CreateDBInstance action to create DB instances for /// the restored DB cluster, specifying the identifier of the restored DB cluster in DBClusterIdentifier. /// You can create DB instances only after the RestoreDBClusterFromS3 action /// has completed and the DB cluster is available. /// /// /// /// For more information on Amazon Aurora, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// This action only applies to Aurora DB clusters. The source DB engine must be MySQL. /// /// ///

/// Container for the necessary parameters to execute the RestoreDBClusterFromS3 service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RestoreDBClusterFromS3 service method, as returned by RDS. /// /// The user already has a DB cluster with the given identifier. /// /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// DBClusterParameterGroupName doesn't refer to an existing DB cluster /// parameter group. /// /// /// The user attempted to create a new DB cluster and the user has already reached the /// maximum allowed DB cluster quota. /// /// /// DBSubnetGroupName doesn't refer to an existing DB subnet group. /// /// /// Domain doesn't refer to an existing Active Directory domain. /// /// /// There is insufficient storage available for the current action. You might be able /// to resolve this error by updating your subnet group to use different Availability /// Zones that have more storage available. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The DB subnet group cannot be deleted because it's in use. /// /// /// The specified Amazon S3 bucket name can't be found or Amazon RDS isn't authorized /// to access the specified Amazon S3 bucket. Verify the SourceS3BucketName and /// S3IngestionRoleArn values and try again. /// /// /// The requested subnet is invalid, or multiple subnets were requested that are not all /// in a common VPC. /// /// /// The DB subnet group doesn't cover all Availability Zones after it's created because /// of users' change. /// /// /// An error occurred accessing an Amazon Web Services KMS key. /// /// /// The request would result in the user exceeding the allowed amount of storage available /// across all DB instances. /// /// /// The specified StorageType can't be associated with the DB instance. /// /// REST API Reference for RestoreDBClusterFromS3 Operation public virtual Task RestoreDBClusterFromS3Async(RestoreDBClusterFromS3Request request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreDBClusterFromS3RequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreDBClusterFromS3ResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RestoreDBClusterFromSnapshot internal virtual RestoreDBClusterFromSnapshotResponse RestoreDBClusterFromSnapshot(RestoreDBClusterFromSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreDBClusterFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreDBClusterFromSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new DB cluster from a DB snapshot or DB cluster snapshot. /// /// /// /// The target DB cluster is created from the source snapshot with a default configuration. /// If you don't specify a security group, the new DB cluster is associated with the default /// security group. /// /// /// /// This action only restores the DB cluster, not the DB instances for that DB cluster. /// You must invoke the CreateDBInstance action to create DB instances for /// the restored DB cluster, specifying the identifier of the restored DB cluster in DBClusterIdentifier. /// You can create DB instances only after the RestoreDBClusterFromSnapshot /// action has completed and the DB cluster is available. /// /// /// /// For more information on Amazon Aurora DB clusters, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the RestoreDBClusterFromSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RestoreDBClusterFromSnapshot service method, as returned by RDS. /// /// The user already has a DB cluster with the given identifier. /// /// /// DBClusterParameterGroupName doesn't refer to an existing DB cluster /// parameter group. /// /// /// The user attempted to create a new DB cluster and the user has already reached the /// maximum allowed DB cluster quota. /// /// /// DBClusterSnapshotIdentifier doesn't refer to an existing DB cluster /// snapshot. /// /// /// DBSnapshotIdentifier doesn't refer to an existing DB snapshot. /// /// /// DBSubnetGroupName doesn't refer to an existing DB subnet group. /// /// /// Domain doesn't refer to an existing Active Directory domain. /// /// /// The DB cluster doesn't have enough capacity for the current operation. /// /// /// There is insufficient storage available for the current action. You might be able /// to resolve this error by updating your subnet group to use different Availability /// Zones that have more storage available. /// /// /// The supplied value isn't a valid DB cluster snapshot state. /// /// /// The DB instance isn't in a valid state. /// /// /// The state of the DB snapshot doesn't allow deletion. /// /// /// Cannot restore from VPC backup to non-VPC DB instance. /// /// /// The requested subnet is invalid, or multiple subnets were requested that are not all /// in a common VPC. /// /// /// The DB subnet group doesn't cover all Availability Zones after it's created because /// of users' change. /// /// /// An error occurred accessing an Amazon Web Services KMS key. /// /// /// The specified option group could not be found. /// /// /// The request would result in the user exceeding the allowed amount of storage available /// across all DB instances. /// /// REST API Reference for RestoreDBClusterFromSnapshot Operation public virtual Task RestoreDBClusterFromSnapshotAsync(RestoreDBClusterFromSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreDBClusterFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreDBClusterFromSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RestoreDBClusterToPointInTime internal virtual RestoreDBClusterToPointInTimeResponse RestoreDBClusterToPointInTime(RestoreDBClusterToPointInTimeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreDBClusterToPointInTimeRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreDBClusterToPointInTimeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Restores a DB cluster to an arbitrary point in time. Users can restore to any point /// in time before LatestRestorableTime for up to BackupRetentionPeriod /// days. The target DB cluster is created from the source DB cluster with the same configuration /// as the original DB cluster, except that the new DB cluster is created with the default /// DB security group. /// /// /// /// For Aurora, this action only restores the DB cluster, not the DB instances for that /// DB cluster. You must invoke the CreateDBInstance action to create DB /// instances for the restored DB cluster, specifying the identifier of the restored DB /// cluster in DBClusterIdentifier. You can create DB instances only after /// the RestoreDBClusterToPointInTime action has completed and the DB cluster /// is available. /// /// /// /// For more information on Amazon Aurora DB clusters, see /// What is Amazon Aurora? in the Amazon Aurora User Guide. /// /// /// /// For more information on Multi-AZ DB clusters, see /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide. /// ///

/// Container for the necessary parameters to execute the RestoreDBClusterToPointInTime service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RestoreDBClusterToPointInTime service method, as returned by RDS. /// /// The user already has a DB cluster with the given identifier. /// /// /// DBClusterIdentifier doesn't refer to an existing DB cluster. /// /// /// DBClusterParameterGroupName doesn't refer to an existing DB cluster /// parameter group. /// /// /// The user attempted to create a new DB cluster and the user has already reached the /// maximum allowed DB cluster quota. /// /// /// DBClusterSnapshotIdentifier doesn't refer to an existing DB cluster /// snapshot. /// /// /// DBSubnetGroupName doesn't refer to an existing DB subnet group. /// /// /// Domain doesn't refer to an existing Active Directory domain. /// /// /// The DB cluster doesn't have enough capacity for the current operation. /// /// /// There is insufficient storage available for the current action. You might be able /// to resolve this error by updating your subnet group to use different Availability /// Zones that have more storage available. /// /// /// The supplied value isn't a valid DB cluster snapshot state. /// /// /// The requested operation can't be performed while the cluster is in this state. /// /// /// The state of the DB snapshot doesn't allow deletion. /// /// /// Cannot restore from VPC backup to non-VPC DB instance. /// /// /// The requested subnet is invalid, or multiple subnets were requested that are not all /// in a common VPC. /// /// /// The DB subnet group doesn't cover all Availability Zones after it's created because /// of users' change. /// /// /// An error occurred accessing an Amazon Web Services KMS key. /// /// /// The specified option group could not be found. /// /// /// The request would result in the user exceeding the allowed amount of storage available /// across all DB instances. /// /// REST API Reference for RestoreDBClusterToPointInTime Operation public virtual Task RestoreDBClusterToPointInTimeAsync(RestoreDBClusterToPointInTimeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreDBClusterToPointInTimeRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreDBClusterToPointInTimeResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RestoreDBInstanceFromDBSnapshot internal virtual RestoreDBInstanceFromDBSnapshotResponse RestoreDBInstanceFromDBSnapshot(RestoreDBInstanceFromDBSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreDBInstanceFromDBSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreDBInstanceFromDBSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new DB instance from a DB snapshot. The target database is created from /// the source database restore point with most of the source's original configuration, /// including the default security group and DB parameter group. By default, the new DB /// instance is created as a Single-AZ deployment, except when the instance is a SQL Server /// instance that has an option group associated with mirroring. In this case, the instance /// becomes a Multi-AZ deployment, not a Single-AZ deployment. /// /// /// /// If you want to replace your original DB instance with the new, restored DB instance, /// then rename your original DB instance before you call the RestoreDBInstanceFromDBSnapshot /// action. RDS doesn't allow two DB instances with the same name. After you have renamed /// your original DB instance with a different identifier, then you can pass the original /// name of the DB instance as the DBInstanceIdentifier in the call to the RestoreDBInstanceFromDBSnapshot /// action. The result is that you replace the original DB instance with the DB instance /// created from the snapshot. /// /// /// /// If you are restoring from a shared manual DB snapshot, the DBSnapshotIdentifier /// must be the ARN of the shared DB snapshot. /// /// /// /// This command doesn't apply to Aurora MySQL and Aurora PostgreSQL. For Aurora, use /// RestoreDBClusterFromSnapshot. /// /// ///

/// Container for the necessary parameters to execute the RestoreDBInstanceFromDBSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RestoreDBInstanceFromDBSnapshot service method, as returned by RDS. /// /// The specified CIDR IP range or Amazon EC2 security group might not be authorized for /// the specified DB security group. /// /// /// /// Or, RDS might not be authorized to perform necessary actions using IAM on your behalf. /// /// /// /// /// /// /// DBClusterSnapshotIdentifier doesn't refer to an existing DB cluster /// snapshot. /// /// /// The user already has a DB instance with the given identifier. /// /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// DBSecurityGroupName doesn't refer to an existing DB security group. /// /// /// DBSnapshotIdentifier doesn't refer to an existing DB snapshot. /// /// /// Subnets in the DB subnet group should cover at least two Availability Zones unless /// there is only one Availability Zone. /// /// /// DBSubnetGroupName doesn't refer to an existing DB subnet group. /// /// /// Domain doesn't refer to an existing Active Directory domain. /// /// /// The request would result in the user exceeding the allowed number of DB instances. /// /// /// The specified DB instance class isn't available in the specified Availability Zone. /// /// /// The state of the DB snapshot doesn't allow deletion. /// /// /// Cannot restore from VPC backup to non-VPC DB instance. /// /// /// The requested subnet is invalid, or multiple subnets were requested that are not all /// in a common VPC. /// /// /// The DB subnet group doesn't cover all Availability Zones after it's created because /// of users' change. /// /// /// An error occurred accessing an Amazon Web Services KMS key. /// /// /// The network type is invalid for the DB instance. Valid nework type values are IPV4 /// and DUAL. /// /// /// The specified option group could not be found. /// /// /// Provisioned IOPS not available in the specified Availability Zone. /// /// /// The request would result in the user exceeding the allowed amount of storage available /// across all DB instances. /// /// /// The specified StorageType can't be associated with the DB instance. /// /// REST API Reference for RestoreDBInstanceFromDBSnapshot Operation public virtual Task RestoreDBInstanceFromDBSnapshotAsync(RestoreDBInstanceFromDBSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreDBInstanceFromDBSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreDBInstanceFromDBSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RestoreDBInstanceFromS3 internal virtual RestoreDBInstanceFromS3Response RestoreDBInstanceFromS3(RestoreDBInstanceFromS3Request request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreDBInstanceFromS3RequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreDBInstanceFromS3ResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Amazon Relational Database Service (Amazon RDS) supports importing MySQL databases /// by using backup files. You can create a backup of your on-premises database, store /// it on Amazon Simple Storage Service (Amazon S3), and then restore the backup file /// onto a new Amazon RDS DB instance running MySQL. For more information, see Importing /// Data into an Amazon RDS MySQL DB Instance in the Amazon RDS User Guide. /// /// /// /// /// This command doesn't apply to RDS Custom. /// ///

/// Container for the necessary parameters to execute the RestoreDBInstanceFromS3 service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RestoreDBInstanceFromS3 service method, as returned by RDS. /// /// The specified CIDR IP range or Amazon EC2 security group might not be authorized for /// the specified DB security group. /// /// /// /// Or, RDS might not be authorized to perform necessary actions using IAM on your behalf. /// /// /// /// /// /// /// The user already has a DB instance with the given identifier. /// /// /// DBParameterGroupName doesn't refer to an existing DB parameter group. /// /// /// DBSecurityGroupName doesn't refer to an existing DB security group. /// /// /// Subnets in the DB subnet group should cover at least two Availability Zones unless /// there is only one Availability Zone. /// /// /// DBSubnetGroupName doesn't refer to an existing DB subnet group. /// /// /// The request would result in the user exceeding the allowed number of DB instances. /// /// /// The specified DB instance class isn't available in the specified Availability Zone. /// /// /// The specified Amazon S3 bucket name can't be found or Amazon RDS isn't authorized /// to access the specified Amazon S3 bucket. Verify the SourceS3BucketName and /// S3IngestionRoleArn values and try again. /// /// /// The requested subnet is invalid, or multiple subnets were requested that are not all /// in a common VPC. /// /// /// The DB subnet group doesn't cover all Availability Zones after it's created because /// of users' change. /// /// /// An error occurred accessing an Amazon Web Services KMS key. /// /// /// The network type is invalid for the DB instance. Valid nework type values are IPV4 /// and DUAL. /// /// /// The specified option group could not be found. /// /// /// Provisioned IOPS not available in the specified Availability Zone. /// /// /// The request would result in the user exceeding the allowed amount of storage available /// across all DB instances. /// /// /// The specified StorageType can't be associated with the DB instance. /// /// REST API Reference for RestoreDBInstanceFromS3 Operation public virtual Task RestoreDBInstanceFromS3Async(RestoreDBInstanceFromS3Request request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreDBInstanceFromS3RequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreDBInstanceFromS3ResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RestoreDBInstanceToPointInTime internal virtual RestoreDBInstanceToPointInTimeResponse RestoreDBInstanceToPointInTime(RestoreDBInstanceToPointInTimeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreDBInstanceToPointInTimeRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreDBInstanceToPointInTimeResponseUnmarshaller.Instance; return Invoke