func (c *RDS) DeleteDBSnapshot(input *DeleteDBSnapshotInput) (*DeleteDBSnapshotOutput, error) {
	req, out := c.DeleteDBSnapshotRequest(input)
	err := req.Send()
	return out, err
}
Deletes a DBSnapshot. If the snapshot is being copied, the copy operation
is terminated.

The DBSnapshot must be in the available state to be deleted.
package rds
import (
	"time"
	"github.com/aws/aws-sdk-go/aws/awsutil"
	"github.com/aws/aws-sdk-go/aws/request"
)
const opAddSourceIdentifierToSubscription = "AddSourceIdentifierToSubscription"
func (c *RDS) AddSourceIdentifierToSubscriptionRequest(input *AddSourceIdentifierToSubscriptionInput) (req *request.Request, output *AddSourceIdentifierToSubscriptionOutput) {
	op := &request.Operation{
		Name:       opAddSourceIdentifierToSubscription,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AddSourceIdentifierToSubscriptionInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AddSourceIdentifierToSubscriptionOutput{}
	req.Data = output
	return
}
func (c *RDS) AddSourceIdentifierToSubscription(input *AddSourceIdentifierToSubscriptionInput) (*AddSourceIdentifierToSubscriptionOutput, error) {
	req, out := c.AddSourceIdentifierToSubscriptionRequest(input)
	err := req.Send()
	return out, err
}
const opAddTagsToResource = "AddTagsToResource"
func (c *RDS) AddTagsToResourceRequest(input *AddTagsToResourceInput) (req *request.Request, output *AddTagsToResourceOutput) {
	op := &request.Operation{
		Name:       opAddTagsToResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AddTagsToResourceInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AddTagsToResourceOutput{}
	req.Data = output
	return
}
func (c *RDS) AddTagsToResource(input *AddTagsToResourceInput) (*AddTagsToResourceOutput, error) {
	req, out := c.AddTagsToResourceRequest(input)
	err := req.Send()
	return out, err
}
const opApplyPendingMaintenanceAction = "ApplyPendingMaintenanceAction"
func (c *RDS) ApplyPendingMaintenanceActionRequest(input *ApplyPendingMaintenanceActionInput) (req *request.Request, output *ApplyPendingMaintenanceActionOutput) {
	op := &request.Operation{
		Name:       opApplyPendingMaintenanceAction,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &ApplyPendingMaintenanceActionInput{}
	}
	req = c.newRequest(op, input, output)
	output = &ApplyPendingMaintenanceActionOutput{}
	req.Data = output
	return
}
func (c *RDS) ApplyPendingMaintenanceAction(input *ApplyPendingMaintenanceActionInput) (*ApplyPendingMaintenanceActionOutput, error) {
	req, out := c.ApplyPendingMaintenanceActionRequest(input)
	err := req.Send()
	return out, err
}
const opAuthorizeDBSecurityGroupIngress = "AuthorizeDBSecurityGroupIngress"
func (c *RDS) AuthorizeDBSecurityGroupIngressRequest(input *AuthorizeDBSecurityGroupIngressInput) (req *request.Request, output *AuthorizeDBSecurityGroupIngressOutput) {
	op := &request.Operation{
		Name:       opAuthorizeDBSecurityGroupIngress,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AuthorizeDBSecurityGroupIngressInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AuthorizeDBSecurityGroupIngressOutput{}
	req.Data = output
	return
}
func (c *RDS) AuthorizeDBSecurityGroupIngress(input *AuthorizeDBSecurityGroupIngressInput) (*AuthorizeDBSecurityGroupIngressOutput, error) {
	req, out := c.AuthorizeDBSecurityGroupIngressRequest(input)
	err := req.Send()
	return out, err
}
const opCopyDBClusterSnapshot = "CopyDBClusterSnapshot"
func (c *RDS) CopyDBClusterSnapshotRequest(input *CopyDBClusterSnapshotInput) (req *request.Request, output *CopyDBClusterSnapshotOutput) {
	op := &request.Operation{
		Name:       opCopyDBClusterSnapshot,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CopyDBClusterSnapshotInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CopyDBClusterSnapshotOutput{}
	req.Data = output
	return
}
func (c *RDS) CopyDBClusterSnapshot(input *CopyDBClusterSnapshotInput) (*CopyDBClusterSnapshotOutput, error) {
	req, out := c.CopyDBClusterSnapshotRequest(input)
	err := req.Send()
	return out, err
}
const opCopyDBParameterGroup = "CopyDBParameterGroup"
func (c *RDS) CopyDBParameterGroupRequest(input *CopyDBParameterGroupInput) (req *request.Request, output *CopyDBParameterGroupOutput) {
	op := &request.Operation{
		Name:       opCopyDBParameterGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CopyDBParameterGroupInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CopyDBParameterGroupOutput{}
	req.Data = output
	return
}
func (c *RDS) CopyDBParameterGroup(input *CopyDBParameterGroupInput) (*CopyDBParameterGroupOutput, error) {
	req, out := c.CopyDBParameterGroupRequest(input)
	err := req.Send()
	return out, err
}
const opCopyDBSnapshot = "CopyDBSnapshot"
func (c *RDS) CopyDBSnapshotRequest(input *CopyDBSnapshotInput) (req *request.Request, output *CopyDBSnapshotOutput) {
	op := &request.Operation{
		Name:       opCopyDBSnapshot,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CopyDBSnapshotInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CopyDBSnapshotOutput{}
	req.Data = output
	return
}
func (c *RDS) CopyDBSnapshot(input *CopyDBSnapshotInput) (*CopyDBSnapshotOutput, error) {
	req, out := c.CopyDBSnapshotRequest(input)
	err := req.Send()
	return out, err
}
const opCopyOptionGroup = "CopyOptionGroup"
func (c *RDS) CopyOptionGroupRequest(input *CopyOptionGroupInput) (req *request.Request, output *CopyOptionGroupOutput) {
	op := &request.Operation{
		Name:       opCopyOptionGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CopyOptionGroupInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CopyOptionGroupOutput{}
	req.Data = output
	return
}
func (c *RDS) CopyOptionGroup(input *CopyOptionGroupInput) (*CopyOptionGroupOutput, error) {
	req, out := c.CopyOptionGroupRequest(input)
	err := req.Send()
	return out, err
}
const opCreateDBCluster = "CreateDBCluster"
func (c *RDS) CreateDBClusterRequest(input *CreateDBClusterInput) (req *request.Request, output *CreateDBClusterOutput) {
	op := &request.Operation{
		Name:       opCreateDBCluster,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateDBClusterInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateDBClusterOutput{}
	req.Data = output
	return
}
func (c *RDS) CreateDBCluster(input *CreateDBClusterInput) (*CreateDBClusterOutput, error) {
	req, out := c.CreateDBClusterRequest(input)
	err := req.Send()
	return out, err
}
const opCreateDBClusterParameterGroup = "CreateDBClusterParameterGroup"
func (c *RDS) CreateDBClusterParameterGroupRequest(input *CreateDBClusterParameterGroupInput) (req *request.Request, output *CreateDBClusterParameterGroupOutput) {
	op := &request.Operation{
		Name:       opCreateDBClusterParameterGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateDBClusterParameterGroupInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateDBClusterParameterGroupOutput{}
	req.Data = output
	return
}
func (c *RDS) CreateDBClusterParameterGroup(input *CreateDBClusterParameterGroupInput) (*CreateDBClusterParameterGroupOutput, error) {
	req, out := c.CreateDBClusterParameterGroupRequest(input)
	err := req.Send()
	return out, err
}
const opCreateDBClusterSnapshot = "CreateDBClusterSnapshot"
func (c *RDS) CreateDBClusterSnapshotRequest(input *CreateDBClusterSnapshotInput) (req *request.Request, output *CreateDBClusterSnapshotOutput) {
	op := &request.Operation{
		Name:       opCreateDBClusterSnapshot,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateDBClusterSnapshotInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateDBClusterSnapshotOutput{}
	req.Data = output
	return
}
func (c *RDS) CreateDBClusterSnapshot(input *CreateDBClusterSnapshotInput) (*CreateDBClusterSnapshotOutput, error) {
	req, out := c.CreateDBClusterSnapshotRequest(input)
	err := req.Send()
	return out, err
}
const opCreateDBInstance = "CreateDBInstance"
func (c *RDS) CreateDBInstanceRequest(input *CreateDBInstanceInput) (req *request.Request, output *CreateDBInstanceOutput) {
	op := &request.Operation{
		Name:       opCreateDBInstance,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateDBInstanceInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateDBInstanceOutput{}
	req.Data = output
	return
}
func (c *RDS) CreateDBInstance(input *CreateDBInstanceInput) (*CreateDBInstanceOutput, error) {
	req, out := c.CreateDBInstanceRequest(input)
	err := req.Send()
	return out, err
}
const opCreateDBInstanceReadReplica = "CreateDBInstanceReadReplica"
func (c *RDS) CreateDBInstanceReadReplicaRequest(input *CreateDBInstanceReadReplicaInput) (req *request.Request, output *CreateDBInstanceReadReplicaOutput) {
	op := &request.Operation{
		Name:       opCreateDBInstanceReadReplica,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateDBInstanceReadReplicaInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateDBInstanceReadReplicaOutput{}
	req.Data = output
	return
}
func (c *RDS) CreateDBInstanceReadReplica(input *CreateDBInstanceReadReplicaInput) (*CreateDBInstanceReadReplicaOutput, error) {
	req, out := c.CreateDBInstanceReadReplicaRequest(input)
	err := req.Send()
	return out, err
}
const opCreateDBParameterGroup = "CreateDBParameterGroup"
func (c *RDS) CreateDBParameterGroupRequest(input *CreateDBParameterGroupInput) (req *request.Request, output *CreateDBParameterGroupOutput) {
	op := &request.Operation{
		Name:       opCreateDBParameterGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateDBParameterGroupInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateDBParameterGroupOutput{}
	req.Data = output
	return
}
func (c *RDS) CreateDBParameterGroup(input *CreateDBParameterGroupInput) (*CreateDBParameterGroupOutput, error) {
	req, out := c.CreateDBParameterGroupRequest(input)
	err := req.Send()
	return out, err
}
const opCreateDBSecurityGroup = "CreateDBSecurityGroup"
func (c *RDS) CreateDBSecurityGroupRequest(input *CreateDBSecurityGroupInput) (req *request.Request, output *CreateDBSecurityGroupOutput) {
	op := &request.Operation{
		Name:       opCreateDBSecurityGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateDBSecurityGroupInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateDBSecurityGroupOutput{}
	req.Data = output
	return
}
func (c *RDS) CreateDBSecurityGroup(input *CreateDBSecurityGroupInput) (*CreateDBSecurityGroupOutput, error) {
	req, out := c.CreateDBSecurityGroupRequest(input)
	err := req.Send()
	return out, err
}
const opCreateDBSnapshot = "CreateDBSnapshot"
func (c *RDS) CreateDBSnapshotRequest(input *CreateDBSnapshotInput) (req *request.Request, output *CreateDBSnapshotOutput) {
	op := &request.Operation{
		Name:       opCreateDBSnapshot,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateDBSnapshotInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateDBSnapshotOutput{}
	req.Data = output
	return
}
func (c *RDS) CreateDBSnapshot(input *CreateDBSnapshotInput) (*CreateDBSnapshotOutput, error) {
	req, out := c.CreateDBSnapshotRequest(input)
	err := req.Send()
	return out, err
}
const opCreateDBSubnetGroup = "CreateDBSubnetGroup"
func (c *RDS) CreateDBSubnetGroupRequest(input *CreateDBSubnetGroupInput) (req *request.Request, output *CreateDBSubnetGroupOutput) {
	op := &request.Operation{
		Name:       opCreateDBSubnetGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateDBSubnetGroupInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateDBSubnetGroupOutput{}
	req.Data = output
	return
}
func (c *RDS) CreateDBSubnetGroup(input *CreateDBSubnetGroupInput) (*CreateDBSubnetGroupOutput, error) {
	req, out := c.CreateDBSubnetGroupRequest(input)
	err := req.Send()
	return out, err
}
const opCreateEventSubscription = "CreateEventSubscription"
func (c *RDS) CreateEventSubscriptionRequest(input *CreateEventSubscriptionInput) (req *request.Request, output *CreateEventSubscriptionOutput) {
	op := &request.Operation{
		Name:       opCreateEventSubscription,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateEventSubscriptionInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateEventSubscriptionOutput{}
	req.Data = output
	return
}
func (c *RDS) CreateEventSubscription(input *CreateEventSubscriptionInput) (*CreateEventSubscriptionOutput, error) {
	req, out := c.CreateEventSubscriptionRequest(input)
	err := req.Send()
	return out, err
}
const opCreateOptionGroup = "CreateOptionGroup"
func (c *RDS) CreateOptionGroupRequest(input *CreateOptionGroupInput) (req *request.Request, output *CreateOptionGroupOutput) {
	op := &request.Operation{
		Name:       opCreateOptionGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateOptionGroupInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateOptionGroupOutput{}
	req.Data = output
	return
}
func (c *RDS) CreateOptionGroup(input *CreateOptionGroupInput) (*CreateOptionGroupOutput, error) {
	req, out := c.CreateOptionGroupRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteDBCluster = "DeleteDBCluster"
func (c *RDS) DeleteDBClusterRequest(input *DeleteDBClusterInput) (req *request.Request, output *DeleteDBClusterOutput) {
	op := &request.Operation{
		Name:       opDeleteDBCluster,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteDBClusterInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteDBClusterOutput{}
	req.Data = output
	return
}
func (c *RDS) DeleteDBCluster(input *DeleteDBClusterInput) (*DeleteDBClusterOutput, error) {
	req, out := c.DeleteDBClusterRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteDBClusterParameterGroup = "DeleteDBClusterParameterGroup"
func (c *RDS) DeleteDBClusterParameterGroupRequest(input *DeleteDBClusterParameterGroupInput) (req *request.Request, output *DeleteDBClusterParameterGroupOutput) {
	op := &request.Operation{
		Name:       opDeleteDBClusterParameterGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteDBClusterParameterGroupInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteDBClusterParameterGroupOutput{}
	req.Data = output
	return
}
func (c *RDS) DeleteDBClusterParameterGroup(input *DeleteDBClusterParameterGroupInput) (*DeleteDBClusterParameterGroupOutput, error) {
	req, out := c.DeleteDBClusterParameterGroupRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteDBClusterSnapshot = "DeleteDBClusterSnapshot"
func (c *RDS) DeleteDBClusterSnapshotRequest(input *DeleteDBClusterSnapshotInput) (req *request.Request, output *DeleteDBClusterSnapshotOutput) {
	op := &request.Operation{
		Name:       opDeleteDBClusterSnapshot,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteDBClusterSnapshotInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteDBClusterSnapshotOutput{}
	req.Data = output
	return
}
func (c *RDS) DeleteDBClusterSnapshot(input *DeleteDBClusterSnapshotInput) (*DeleteDBClusterSnapshotOutput, error) {
	req, out := c.DeleteDBClusterSnapshotRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteDBInstance = "DeleteDBInstance"
func (c *RDS) DeleteDBInstanceRequest(input *DeleteDBInstanceInput) (req *request.Request, output *DeleteDBInstanceOutput) {
	op := &request.Operation{
		Name:       opDeleteDBInstance,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteDBInstanceInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteDBInstanceOutput{}
	req.Data = output
	return
}
func (c *RDS) DeleteDBInstance(input *DeleteDBInstanceInput) (*DeleteDBInstanceOutput, error) {
	req, out := c.DeleteDBInstanceRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteDBParameterGroup = "DeleteDBParameterGroup"
func (c *RDS) DeleteDBParameterGroupRequest(input *DeleteDBParameterGroupInput) (req *request.Request, output *DeleteDBParameterGroupOutput) {
	op := &request.Operation{
		Name:       opDeleteDBParameterGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteDBParameterGroupInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteDBParameterGroupOutput{}
	req.Data = output
	return
}
func (c *RDS) DeleteDBParameterGroup(input *DeleteDBParameterGroupInput) (*DeleteDBParameterGroupOutput, error) {
	req, out := c.DeleteDBParameterGroupRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteDBSecurityGroup = "DeleteDBSecurityGroup"
func (c *RDS) DeleteDBSecurityGroupRequest(input *DeleteDBSecurityGroupInput) (req *request.Request, output *DeleteDBSecurityGroupOutput) {
	op := &request.Operation{
		Name:       opDeleteDBSecurityGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteDBSecurityGroupInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteDBSecurityGroupOutput{}
	req.Data = output
	return
}
func (c *RDS) DeleteDBSecurityGroup(input *DeleteDBSecurityGroupInput) (*DeleteDBSecurityGroupOutput, error) {
	req, out := c.DeleteDBSecurityGroupRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteDBSnapshot = "DeleteDBSnapshot"
func (c *RDS) DeleteDBSnapshotRequest(input *DeleteDBSnapshotInput) (req *request.Request, output *DeleteDBSnapshotOutput) {
	op := &request.Operation{
		Name:       opDeleteDBSnapshot,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteDBSnapshotInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteDBSnapshotOutput{}
	req.Data = output
	return
}