stub.go

// Generated by github.com/temporalio/temporal-aws-sdk-generator
// from github.com/aws/aws-sdk-go version 1.35.7

package rdsstub

import (
	"github.com/aws/aws-sdk-go/service/rds"
	"go.uber.org/cadence/workflow"

	"github.com/banzaicloud/cadence-aws-sdk/clients"
)

// ensure that imports are valid even if not used by the generated code
var _ clients.VoidFuture

type stub struct{}

type AddRoleToDBClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *AddRoleToDBClusterFuture) Get(ctx workflow.Context) (*rds.AddRoleToDBClusterOutput, error) {
	var output rds.AddRoleToDBClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type AddRoleToDBInstanceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *AddRoleToDBInstanceFuture) Get(ctx workflow.Context) (*rds.AddRoleToDBInstanceOutput, error) {
	var output rds.AddRoleToDBInstanceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type AddSourceIdentifierToSubscriptionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *AddSourceIdentifierToSubscriptionFuture) Get(ctx workflow.Context) (*rds.AddSourceIdentifierToSubscriptionOutput, error) {
	var output rds.AddSourceIdentifierToSubscriptionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type AddTagsToResourceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *AddTagsToResourceFuture) Get(ctx workflow.Context) (*rds.AddTagsToResourceOutput, error) {
	var output rds.AddTagsToResourceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ApplyPendingMaintenanceActionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ApplyPendingMaintenanceActionFuture) Get(ctx workflow.Context) (*rds.ApplyPendingMaintenanceActionOutput, error) {
	var output rds.ApplyPendingMaintenanceActionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type AuthorizeDBSecurityGroupIngressFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *AuthorizeDBSecurityGroupIngressFuture) Get(ctx workflow.Context) (*rds.AuthorizeDBSecurityGroupIngressOutput, error) {
	var output rds.AuthorizeDBSecurityGroupIngressOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type BacktrackDBClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *BacktrackDBClusterFuture) Get(ctx workflow.Context) (*rds.BacktrackDBClusterOutput, error) {
	var output rds.BacktrackDBClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CancelExportTaskFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CancelExportTaskFuture) Get(ctx workflow.Context) (*rds.CancelExportTaskOutput, error) {
	var output rds.CancelExportTaskOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CopyDBClusterParameterGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CopyDBClusterParameterGroupFuture) Get(ctx workflow.Context) (*rds.CopyDBClusterParameterGroupOutput, error) {
	var output rds.CopyDBClusterParameterGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CopyDBClusterSnapshotFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CopyDBClusterSnapshotFuture) Get(ctx workflow.Context) (*rds.CopyDBClusterSnapshotOutput, error) {
	var output rds.CopyDBClusterSnapshotOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CopyDBParameterGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CopyDBParameterGroupFuture) Get(ctx workflow.Context) (*rds.CopyDBParameterGroupOutput, error) {
	var output rds.CopyDBParameterGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CopyDBSnapshotFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CopyDBSnapshotFuture) Get(ctx workflow.Context) (*rds.CopyDBSnapshotOutput, error) {
	var output rds.CopyDBSnapshotOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CopyOptionGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CopyOptionGroupFuture) Get(ctx workflow.Context) (*rds.CopyOptionGroupOutput, error) {
	var output rds.CopyOptionGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateCustomAvailabilityZoneFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateCustomAvailabilityZoneFuture) Get(ctx workflow.Context) (*rds.CreateCustomAvailabilityZoneOutput, error) {
	var output rds.CreateCustomAvailabilityZoneOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDBClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDBClusterFuture) Get(ctx workflow.Context) (*rds.CreateDBClusterOutput, error) {
	var output rds.CreateDBClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDBClusterEndpointFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDBClusterEndpointFuture) Get(ctx workflow.Context) (*rds.CreateDBClusterEndpointOutput, error) {
	var output rds.CreateDBClusterEndpointOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDBClusterParameterGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDBClusterParameterGroupFuture) Get(ctx workflow.Context) (*rds.CreateDBClusterParameterGroupOutput, error) {
	var output rds.CreateDBClusterParameterGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDBClusterSnapshotFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDBClusterSnapshotFuture) Get(ctx workflow.Context) (*rds.CreateDBClusterSnapshotOutput, error) {
	var output rds.CreateDBClusterSnapshotOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDBInstanceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDBInstanceFuture) Get(ctx workflow.Context) (*rds.CreateDBInstanceOutput, error) {
	var output rds.CreateDBInstanceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDBInstanceReadReplicaFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDBInstanceReadReplicaFuture) Get(ctx workflow.Context) (*rds.CreateDBInstanceReadReplicaOutput, error) {
	var output rds.CreateDBInstanceReadReplicaOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDBParameterGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDBParameterGroupFuture) Get(ctx workflow.Context) (*rds.CreateDBParameterGroupOutput, error) {
	var output rds.CreateDBParameterGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDBProxyFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDBProxyFuture) Get(ctx workflow.Context) (*rds.CreateDBProxyOutput, error) {
	var output rds.CreateDBProxyOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDBSecurityGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDBSecurityGroupFuture) Get(ctx workflow.Context) (*rds.CreateDBSecurityGroupOutput, error) {
	var output rds.CreateDBSecurityGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDBSnapshotFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDBSnapshotFuture) Get(ctx workflow.Context) (*rds.CreateDBSnapshotOutput, error) {
	var output rds.CreateDBSnapshotOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDBSubnetGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDBSubnetGroupFuture) Get(ctx workflow.Context) (*rds.CreateDBSubnetGroupOutput, error) {
	var output rds.CreateDBSubnetGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateEventSubscriptionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateEventSubscriptionFuture) Get(ctx workflow.Context) (*rds.CreateEventSubscriptionOutput, error) {
	var output rds.CreateEventSubscriptionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateGlobalClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateGlobalClusterFuture) Get(ctx workflow.Context) (*rds.CreateGlobalClusterOutput, error) {
	var output rds.CreateGlobalClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateOptionGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateOptionGroupFuture) Get(ctx workflow.Context) (*rds.CreateOptionGroupOutput, error) {
	var output rds.CreateOptionGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteCustomAvailabilityZoneFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteCustomAvailabilityZoneFuture) Get(ctx workflow.Context) (*rds.DeleteCustomAvailabilityZoneOutput, error) {
	var output rds.DeleteCustomAvailabilityZoneOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDBClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDBClusterFuture) Get(ctx workflow.Context) (*rds.DeleteDBClusterOutput, error) {
	var output rds.DeleteDBClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDBClusterEndpointFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDBClusterEndpointFuture) Get(ctx workflow.Context) (*rds.DeleteDBClusterEndpointOutput, error) {
	var output rds.DeleteDBClusterEndpointOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDBClusterParameterGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDBClusterParameterGroupFuture) Get(ctx workflow.Context) (*rds.DeleteDBClusterParameterGroupOutput, error) {
	var output rds.DeleteDBClusterParameterGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDBClusterSnapshotFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDBClusterSnapshotFuture) Get(ctx workflow.Context) (*rds.DeleteDBClusterSnapshotOutput, error) {
	var output rds.DeleteDBClusterSnapshotOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDBInstanceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDBInstanceFuture) Get(ctx workflow.Context) (*rds.DeleteDBInstanceOutput, error) {
	var output rds.DeleteDBInstanceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDBInstanceAutomatedBackupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDBInstanceAutomatedBackupFuture) Get(ctx workflow.Context) (*rds.DeleteDBInstanceAutomatedBackupOutput, error) {
	var output rds.DeleteDBInstanceAutomatedBackupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDBParameterGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDBParameterGroupFuture) Get(ctx workflow.Context) (*rds.DeleteDBParameterGroupOutput, error) {
	var output rds.DeleteDBParameterGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDBProxyFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDBProxyFuture) Get(ctx workflow.Context) (*rds.DeleteDBProxyOutput, error) {
	var output rds.DeleteDBProxyOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDBSecurityGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDBSecurityGroupFuture) Get(ctx workflow.Context) (*rds.DeleteDBSecurityGroupOutput, error) {
	var output rds.DeleteDBSecurityGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDBSnapshotFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDBSnapshotFuture) Get(ctx workflow.Context) (*rds.DeleteDBSnapshotOutput, error) {
	var output rds.DeleteDBSnapshotOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDBSubnetGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDBSubnetGroupFuture) Get(ctx workflow.Context) (*rds.DeleteDBSubnetGroupOutput, error) {
	var output rds.DeleteDBSubnetGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteEventSubscriptionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteEventSubscriptionFuture) Get(ctx workflow.Context) (*rds.DeleteEventSubscriptionOutput, error) {
	var output rds.DeleteEventSubscriptionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteGlobalClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteGlobalClusterFuture) Get(ctx workflow.Context) (*rds.DeleteGlobalClusterOutput, error) {
	var output rds.DeleteGlobalClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteInstallationMediaFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteInstallationMediaFuture) Get(ctx workflow.Context) (*rds.DeleteInstallationMediaOutput, error) {
	var output rds.DeleteInstallationMediaOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteOptionGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteOptionGroupFuture) Get(ctx workflow.Context) (*rds.DeleteOptionGroupOutput, error) {
	var output rds.DeleteOptionGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeregisterDBProxyTargetsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeregisterDBProxyTargetsFuture) Get(ctx workflow.Context) (*rds.DeregisterDBProxyTargetsOutput, error) {
	var output rds.DeregisterDBProxyTargetsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeAccountAttributesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeAccountAttributesFuture) Get(ctx workflow.Context) (*rds.DescribeAccountAttributesOutput, error) {
	var output rds.DescribeAccountAttributesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeCertificatesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeCertificatesFuture) Get(ctx workflow.Context) (*rds.DescribeCertificatesOutput, error) {
	var output rds.DescribeCertificatesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeCustomAvailabilityZonesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeCustomAvailabilityZonesFuture) Get(ctx workflow.Context) (*rds.DescribeCustomAvailabilityZonesOutput, error) {
	var output rds.DescribeCustomAvailabilityZonesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBClusterBacktracksFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBClusterBacktracksFuture) Get(ctx workflow.Context) (*rds.DescribeDBClusterBacktracksOutput, error) {
	var output rds.DescribeDBClusterBacktracksOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBClusterEndpointsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBClusterEndpointsFuture) Get(ctx workflow.Context) (*rds.DescribeDBClusterEndpointsOutput, error) {
	var output rds.DescribeDBClusterEndpointsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBClusterParameterGroupsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBClusterParameterGroupsFuture) Get(ctx workflow.Context) (*rds.DescribeDBClusterParameterGroupsOutput, error) {
	var output rds.DescribeDBClusterParameterGroupsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBClusterParametersFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBClusterParametersFuture) Get(ctx workflow.Context) (*rds.DescribeDBClusterParametersOutput, error) {
	var output rds.DescribeDBClusterParametersOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBClusterSnapshotAttributesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBClusterSnapshotAttributesFuture) Get(ctx workflow.Context) (*rds.DescribeDBClusterSnapshotAttributesOutput, error) {
	var output rds.DescribeDBClusterSnapshotAttributesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBClusterSnapshotsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBClusterSnapshotsFuture) Get(ctx workflow.Context) (*rds.DescribeDBClusterSnapshotsOutput, error) {
	var output rds.DescribeDBClusterSnapshotsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBClustersFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBClustersFuture) Get(ctx workflow.Context) (*rds.DescribeDBClustersOutput, error) {
	var output rds.DescribeDBClustersOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBEngineVersionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBEngineVersionsFuture) Get(ctx workflow.Context) (*rds.DescribeDBEngineVersionsOutput, error) {
	var output rds.DescribeDBEngineVersionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBInstanceAutomatedBackupsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBInstanceAutomatedBackupsFuture) Get(ctx workflow.Context) (*rds.DescribeDBInstanceAutomatedBackupsOutput, error) {
	var output rds.DescribeDBInstanceAutomatedBackupsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBInstancesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBInstancesFuture) Get(ctx workflow.Context) (*rds.DescribeDBInstancesOutput, error) {
	var output rds.DescribeDBInstancesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBLogFilesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBLogFilesFuture) Get(ctx workflow.Context) (*rds.DescribeDBLogFilesOutput, error) {
	var output rds.DescribeDBLogFilesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBParameterGroupsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBParameterGroupsFuture) Get(ctx workflow.Context) (*rds.DescribeDBParameterGroupsOutput, error) {
	var output rds.DescribeDBParameterGroupsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBParametersFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBParametersFuture) Get(ctx workflow.Context) (*rds.DescribeDBParametersOutput, error) {
	var output rds.DescribeDBParametersOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBProxiesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBProxiesFuture) Get(ctx workflow.Context) (*rds.DescribeDBProxiesOutput, error) {
	var output rds.DescribeDBProxiesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBProxyTargetGroupsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBProxyTargetGroupsFuture) Get(ctx workflow.Context) (*rds.DescribeDBProxyTargetGroupsOutput, error) {
	var output rds.DescribeDBProxyTargetGroupsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBProxyTargetsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBProxyTargetsFuture) Get(ctx workflow.Context) (*rds.DescribeDBProxyTargetsOutput, error) {
	var output rds.DescribeDBProxyTargetsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBSecurityGroupsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBSecurityGroupsFuture) Get(ctx workflow.Context) (*rds.DescribeDBSecurityGroupsOutput, error) {
	var output rds.DescribeDBSecurityGroupsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBSnapshotAttributesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBSnapshotAttributesFuture) Get(ctx workflow.Context) (*rds.DescribeDBSnapshotAttributesOutput, error) {
	var output rds.DescribeDBSnapshotAttributesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBSnapshotsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBSnapshotsFuture) Get(ctx workflow.Context) (*rds.DescribeDBSnapshotsOutput, error) {
	var output rds.DescribeDBSnapshotsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDBSubnetGroupsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDBSubnetGroupsFuture) Get(ctx workflow.Context) (*rds.DescribeDBSubnetGroupsOutput, error) {
	var output rds.DescribeDBSubnetGroupsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeEngineDefaultClusterParametersFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeEngineDefaultClusterParametersFuture) Get(ctx workflow.Context) (*rds.DescribeEngineDefaultClusterParametersOutput, error) {
	var output rds.DescribeEngineDefaultClusterParametersOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeEngineDefaultParametersFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeEngineDefaultParametersFuture) Get(ctx workflow.Context) (*rds.DescribeEngineDefaultParametersOutput, error) {
	var output rds.DescribeEngineDefaultParametersOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeEventCategoriesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeEventCategoriesFuture) Get(ctx workflow.Context) (*rds.DescribeEventCategoriesOutput, error) {
	var output rds.DescribeEventCategoriesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeEventSubscriptionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeEventSubscriptionsFuture) Get(ctx workflow.Context) (*rds.DescribeEventSubscriptionsOutput, error) {
	var output rds.DescribeEventSubscriptionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeEventsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeEventsFuture) Get(ctx workflow.Context) (*rds.DescribeEventsOutput, error) {
	var output rds.DescribeEventsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeExportTasksFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeExportTasksFuture) Get(ctx workflow.Context) (*rds.DescribeExportTasksOutput, error) {
	var output rds.DescribeExportTasksOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeGlobalClustersFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeGlobalClustersFuture) Get(ctx workflow.Context) (*rds.DescribeGlobalClustersOutput, error) {
	var output rds.DescribeGlobalClustersOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeInstallationMediaFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeInstallationMediaFuture) Get(ctx workflow.Context) (*rds.DescribeInstallationMediaOutput, error) {
	var output rds.DescribeInstallationMediaOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeOptionGroupOptionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeOptionGroupOptionsFuture) Get(ctx workflow.Context) (*rds.DescribeOptionGroupOptionsOutput, error) {
	var output rds.DescribeOptionGroupOptionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeOptionGroupsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeOptionGroupsFuture) Get(ctx workflow.Context) (*rds.DescribeOptionGroupsOutput, error) {
	var output rds.DescribeOptionGroupsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeOrderableDBInstanceOptionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeOrderableDBInstanceOptionsFuture) Get(ctx workflow.Context) (*rds.DescribeOrderableDBInstanceOptionsOutput, error) {
	var output rds.DescribeOrderableDBInstanceOptionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribePendingMaintenanceActionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribePendingMaintenanceActionsFuture) Get(ctx workflow.Context) (*rds.DescribePendingMaintenanceActionsOutput, error) {
	var output rds.DescribePendingMaintenanceActionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeReservedDBInstancesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeReservedDBInstancesFuture) Get(ctx workflow.Context) (*rds.DescribeReservedDBInstancesOutput, error) {
	var output rds.DescribeReservedDBInstancesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeReservedDBInstancesOfferingsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeReservedDBInstancesOfferingsFuture) Get(ctx workflow.Context) (*rds.DescribeReservedDBInstancesOfferingsOutput, error) {
	var output rds.DescribeReservedDBInstancesOfferingsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeSourceRegionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeSourceRegionsFuture) Get(ctx workflow.Context) (*rds.DescribeSourceRegionsOutput, error) {
	var output rds.DescribeSourceRegionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeValidDBInstanceModificationsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeValidDBInstanceModificationsFuture) Get(ctx workflow.Context) (*rds.DescribeValidDBInstanceModificationsOutput, error) {
	var output rds.DescribeValidDBInstanceModificationsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DownloadDBLogFilePortionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DownloadDBLogFilePortionFuture) Get(ctx workflow.Context) (*rds.DownloadDBLogFilePortionOutput, error) {
	var output rds.DownloadDBLogFilePortionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type FailoverDBClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *FailoverDBClusterFuture) Get(ctx workflow.Context) (*rds.FailoverDBClusterOutput, error) {
	var output rds.FailoverDBClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ImportInstallationMediaFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ImportInstallationMediaFuture) Get(ctx workflow.Context) (*rds.ImportInstallationMediaOutput, error) {
	var output rds.ImportInstallationMediaOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListTagsForResourceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListTagsForResourceFuture) Get(ctx workflow.Context) (*rds.ListTagsForResourceOutput, error) {
	var output rds.ListTagsForResourceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyCertificatesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyCertificatesFuture) Get(ctx workflow.Context) (*rds.ModifyCertificatesOutput, error) {
	var output rds.ModifyCertificatesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyCurrentDBClusterCapacityFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyCurrentDBClusterCapacityFuture) Get(ctx workflow.Context) (*rds.ModifyCurrentDBClusterCapacityOutput, error) {
	var output rds.ModifyCurrentDBClusterCapacityOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyDBClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyDBClusterFuture) Get(ctx workflow.Context) (*rds.ModifyDBClusterOutput, error) {
	var output rds.ModifyDBClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyDBClusterEndpointFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyDBClusterEndpointFuture) Get(ctx workflow.Context) (*rds.ModifyDBClusterEndpointOutput, error) {
	var output rds.ModifyDBClusterEndpointOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyDBClusterParameterGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyDBClusterParameterGroupFuture) Get(ctx workflow.Context) (*rds.DBClusterParameterGroupNameMessage, error) {
	var output rds.DBClusterParameterGroupNameMessage
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyDBClusterSnapshotAttributeFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyDBClusterSnapshotAttributeFuture) Get(ctx workflow.Context) (*rds.ModifyDBClusterSnapshotAttributeOutput, error) {
	var output rds.ModifyDBClusterSnapshotAttributeOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyDBInstanceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyDBInstanceFuture) Get(ctx workflow.Context) (*rds.ModifyDBInstanceOutput, error) {
	var output rds.ModifyDBInstanceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyDBParameterGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyDBParameterGroupFuture) Get(ctx workflow.Context) (*rds.DBParameterGroupNameMessage, error) {
	var output rds.DBParameterGroupNameMessage
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyDBProxyFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyDBProxyFuture) Get(ctx workflow.Context) (*rds.ModifyDBProxyOutput, error) {
	var output rds.ModifyDBProxyOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyDBProxyTargetGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyDBProxyTargetGroupFuture) Get(ctx workflow.Context) (*rds.ModifyDBProxyTargetGroupOutput, error) {
	var output rds.ModifyDBProxyTargetGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyDBSnapshotFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyDBSnapshotFuture) Get(ctx workflow.Context) (*rds.ModifyDBSnapshotOutput, error) {
	var output rds.ModifyDBSnapshotOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyDBSnapshotAttributeFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyDBSnapshotAttributeFuture) Get(ctx workflow.Context) (*rds.ModifyDBSnapshotAttributeOutput, error) {
	var output rds.ModifyDBSnapshotAttributeOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyDBSubnetGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyDBSubnetGroupFuture) Get(ctx workflow.Context) (*rds.ModifyDBSubnetGroupOutput, error) {
	var output rds.ModifyDBSubnetGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyEventSubscriptionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyEventSubscriptionFuture) Get(ctx workflow.Context) (*rds.ModifyEventSubscriptionOutput, error) {
	var output rds.ModifyEventSubscriptionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyGlobalClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyGlobalClusterFuture) Get(ctx workflow.Context) (*rds.ModifyGlobalClusterOutput, error) {
	var output rds.ModifyGlobalClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ModifyOptionGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ModifyOptionGroupFuture) Get(ctx workflow.Context) (*rds.ModifyOptionGroupOutput, error) {
	var output rds.ModifyOptionGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type PromoteReadReplicaFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *PromoteReadReplicaFuture) Get(ctx workflow.Context) (*rds.PromoteReadReplicaOutput, error) {
	var output rds.PromoteReadReplicaOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type PromoteReadReplicaDBClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *PromoteReadReplicaDBClusterFuture) Get(ctx workflow.Context) (*rds.PromoteReadReplicaDBClusterOutput, error) {
	var output rds.PromoteReadReplicaDBClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type PurchaseReservedDBInstancesOfferingFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *PurchaseReservedDBInstancesOfferingFuture) Get(ctx workflow.Context) (*rds.PurchaseReservedDBInstancesOfferingOutput, error) {
	var output rds.PurchaseReservedDBInstancesOfferingOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RebootDBInstanceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RebootDBInstanceFuture) Get(ctx workflow.Context) (*rds.RebootDBInstanceOutput, error) {
	var output rds.RebootDBInstanceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RegisterDBProxyTargetsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RegisterDBProxyTargetsFuture) Get(ctx workflow.Context) (*rds.RegisterDBProxyTargetsOutput, error) {
	var output rds.RegisterDBProxyTargetsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RemoveFromGlobalClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RemoveFromGlobalClusterFuture) Get(ctx workflow.Context) (*rds.RemoveFromGlobalClusterOutput, error) {
	var output rds.RemoveFromGlobalClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RemoveRoleFromDBClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RemoveRoleFromDBClusterFuture) Get(ctx workflow.Context) (*rds.RemoveRoleFromDBClusterOutput, error) {
	var output rds.RemoveRoleFromDBClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RemoveRoleFromDBInstanceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RemoveRoleFromDBInstanceFuture) Get(ctx workflow.Context) (*rds.RemoveRoleFromDBInstanceOutput, error) {
	var output rds.RemoveRoleFromDBInstanceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RemoveSourceIdentifierFromSubscriptionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RemoveSourceIdentifierFromSubscriptionFuture) Get(ctx workflow.Context) (*rds.RemoveSourceIdentifierFromSubscriptionOutput, error) {
	var output rds.RemoveSourceIdentifierFromSubscriptionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RemoveTagsFromResourceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RemoveTagsFromResourceFuture) Get(ctx workflow.Context) (*rds.RemoveTagsFromResourceOutput, error) {
	var output rds.RemoveTagsFromResourceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ResetDBClusterParameterGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ResetDBClusterParameterGroupFuture) Get(ctx workflow.Context) (*rds.DBClusterParameterGroupNameMessage, error) {
	var output rds.DBClusterParameterGroupNameMessage
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ResetDBParameterGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ResetDBParameterGroupFuture) Get(ctx workflow.Context) (*rds.DBParameterGroupNameMessage, error) {
	var output rds.DBParameterGroupNameMessage
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RestoreDBClusterFromS3Future struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RestoreDBClusterFromS3Future) Get(ctx workflow.Context) (*rds.RestoreDBClusterFromS3Output, error) {
	var output rds.RestoreDBClusterFromS3Output
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RestoreDBClusterFromSnapshotFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RestoreDBClusterFromSnapshotFuture) Get(ctx workflow.Context) (*rds.RestoreDBClusterFromSnapshotOutput, error) {
	var output rds.RestoreDBClusterFromSnapshotOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RestoreDBClusterToPointInTimeFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RestoreDBClusterToPointInTimeFuture) Get(ctx workflow.Context) (*rds.RestoreDBClusterToPointInTimeOutput, error) {
	var output rds.RestoreDBClusterToPointInTimeOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RestoreDBInstanceFromDBSnapshotFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RestoreDBInstanceFromDBSnapshotFuture) Get(ctx workflow.Context) (*rds.RestoreDBInstanceFromDBSnapshotOutput, error) {
	var output rds.RestoreDBInstanceFromDBSnapshotOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RestoreDBInstanceFromS3Future struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RestoreDBInstanceFromS3Future) Get(ctx workflow.Context) (*rds.RestoreDBInstanceFromS3Output, error) {
	var output rds.RestoreDBInstanceFromS3Output
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RestoreDBInstanceToPointInTimeFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RestoreDBInstanceToPointInTimeFuture) Get(ctx workflow.Context) (*rds.RestoreDBInstanceToPointInTimeOutput, error) {
	var output rds.RestoreDBInstanceToPointInTimeOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RevokeDBSecurityGroupIngressFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RevokeDBSecurityGroupIngressFuture) Get(ctx workflow.Context) (*rds.RevokeDBSecurityGroupIngressOutput, error) {
	var output rds.RevokeDBSecurityGroupIngressOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type StartActivityStreamFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *StartActivityStreamFuture) Get(ctx workflow.Context) (*rds.StartActivityStreamOutput, error) {
	var output rds.StartActivityStreamOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type StartDBClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *StartDBClusterFuture) Get(ctx workflow.Context) (*rds.StartDBClusterOutput, error) {
	var output rds.StartDBClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type StartDBInstanceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *StartDBInstanceFuture) Get(ctx workflow.Context) (*rds.StartDBInstanceOutput, error) {
	var output rds.StartDBInstanceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type StartDBInstanceAutomatedBackupsReplicationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *StartDBInstanceAutomatedBackupsReplicationFuture) Get(ctx workflow.Context) (*rds.StartDBInstanceAutomatedBackupsReplicationOutput, error) {
	var output rds.StartDBInstanceAutomatedBackupsReplicationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type StartExportTaskFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *StartExportTaskFuture) Get(ctx workflow.Context) (*rds.StartExportTaskOutput, error) {
	var output rds.StartExportTaskOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type StopActivityStreamFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *StopActivityStreamFuture) Get(ctx workflow.Context) (*rds.StopActivityStreamOutput, error) {
	var output rds.StopActivityStreamOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type StopDBClusterFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *StopDBClusterFuture) Get(ctx workflow.Context) (*rds.StopDBClusterOutput, error) {
	var output rds.StopDBClusterOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type StopDBInstanceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *StopDBInstanceFuture) Get(ctx workflow.Context) (*rds.StopDBInstanceOutput, error) {
	var output rds.StopDBInstanceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type StopDBInstanceAutomatedBackupsReplicationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *StopDBInstanceAutomatedBackupsReplicationFuture) Get(ctx workflow.Context) (*rds.StopDBInstanceAutomatedBackupsReplicationOutput, error) {
	var output rds.StopDBInstanceAutomatedBackupsReplicationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

func (a *stub) AddRoleToDBCluster(ctx workflow.Context, input *rds.AddRoleToDBClusterInput) (*rds.AddRoleToDBClusterOutput, error) {
	var output rds.AddRoleToDBClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-AddRoleToDBCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) AddRoleToDBClusterAsync(ctx workflow.Context, input *rds.AddRoleToDBClusterInput) *AddRoleToDBClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-AddRoleToDBCluster", input)
	return &AddRoleToDBClusterFuture{Future: future}
}

func (a *stub) AddRoleToDBInstance(ctx workflow.Context, input *rds.AddRoleToDBInstanceInput) (*rds.AddRoleToDBInstanceOutput, error) {
	var output rds.AddRoleToDBInstanceOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-AddRoleToDBInstance", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) AddRoleToDBInstanceAsync(ctx workflow.Context, input *rds.AddRoleToDBInstanceInput) *AddRoleToDBInstanceFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-AddRoleToDBInstance", input)
	return &AddRoleToDBInstanceFuture{Future: future}
}

func (a *stub) AddSourceIdentifierToSubscription(ctx workflow.Context, input *rds.AddSourceIdentifierToSubscriptionInput) (*rds.AddSourceIdentifierToSubscriptionOutput, error) {
	var output rds.AddSourceIdentifierToSubscriptionOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-AddSourceIdentifierToSubscription", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) AddSourceIdentifierToSubscriptionAsync(ctx workflow.Context, input *rds.AddSourceIdentifierToSubscriptionInput) *AddSourceIdentifierToSubscriptionFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-AddSourceIdentifierToSubscription", input)
	return &AddSourceIdentifierToSubscriptionFuture{Future: future}
}

func (a *stub) AddTagsToResource(ctx workflow.Context, input *rds.AddTagsToResourceInput) (*rds.AddTagsToResourceOutput, error) {
	var output rds.AddTagsToResourceOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-AddTagsToResource", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) AddTagsToResourceAsync(ctx workflow.Context, input *rds.AddTagsToResourceInput) *AddTagsToResourceFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-AddTagsToResource", input)
	return &AddTagsToResourceFuture{Future: future}
}

func (a *stub) ApplyPendingMaintenanceAction(ctx workflow.Context, input *rds.ApplyPendingMaintenanceActionInput) (*rds.ApplyPendingMaintenanceActionOutput, error) {
	var output rds.ApplyPendingMaintenanceActionOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ApplyPendingMaintenanceAction", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ApplyPendingMaintenanceActionAsync(ctx workflow.Context, input *rds.ApplyPendingMaintenanceActionInput) *ApplyPendingMaintenanceActionFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ApplyPendingMaintenanceAction", input)
	return &ApplyPendingMaintenanceActionFuture{Future: future}
}

func (a *stub) AuthorizeDBSecurityGroupIngress(ctx workflow.Context, input *rds.AuthorizeDBSecurityGroupIngressInput) (*rds.AuthorizeDBSecurityGroupIngressOutput, error) {
	var output rds.AuthorizeDBSecurityGroupIngressOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-AuthorizeDBSecurityGroupIngress", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) AuthorizeDBSecurityGroupIngressAsync(ctx workflow.Context, input *rds.AuthorizeDBSecurityGroupIngressInput) *AuthorizeDBSecurityGroupIngressFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-AuthorizeDBSecurityGroupIngress", input)
	return &AuthorizeDBSecurityGroupIngressFuture{Future: future}
}

func (a *stub) BacktrackDBCluster(ctx workflow.Context, input *rds.BacktrackDBClusterInput) (*rds.BacktrackDBClusterOutput, error) {
	var output rds.BacktrackDBClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-BacktrackDBCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) BacktrackDBClusterAsync(ctx workflow.Context, input *rds.BacktrackDBClusterInput) *BacktrackDBClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-BacktrackDBCluster", input)
	return &BacktrackDBClusterFuture{Future: future}
}

func (a *stub) CancelExportTask(ctx workflow.Context, input *rds.CancelExportTaskInput) (*rds.CancelExportTaskOutput, error) {
	var output rds.CancelExportTaskOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CancelExportTask", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CancelExportTaskAsync(ctx workflow.Context, input *rds.CancelExportTaskInput) *CancelExportTaskFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CancelExportTask", input)
	return &CancelExportTaskFuture{Future: future}
}

func (a *stub) CopyDBClusterParameterGroup(ctx workflow.Context, input *rds.CopyDBClusterParameterGroupInput) (*rds.CopyDBClusterParameterGroupOutput, error) {
	var output rds.CopyDBClusterParameterGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CopyDBClusterParameterGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CopyDBClusterParameterGroupAsync(ctx workflow.Context, input *rds.CopyDBClusterParameterGroupInput) *CopyDBClusterParameterGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CopyDBClusterParameterGroup", input)
	return &CopyDBClusterParameterGroupFuture{Future: future}
}

func (a *stub) CopyDBClusterSnapshot(ctx workflow.Context, input *rds.CopyDBClusterSnapshotInput) (*rds.CopyDBClusterSnapshotOutput, error) {
	var output rds.CopyDBClusterSnapshotOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CopyDBClusterSnapshot", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CopyDBClusterSnapshotAsync(ctx workflow.Context, input *rds.CopyDBClusterSnapshotInput) *CopyDBClusterSnapshotFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CopyDBClusterSnapshot", input)
	return &CopyDBClusterSnapshotFuture{Future: future}
}

func (a *stub) CopyDBParameterGroup(ctx workflow.Context, input *rds.CopyDBParameterGroupInput) (*rds.CopyDBParameterGroupOutput, error) {
	var output rds.CopyDBParameterGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CopyDBParameterGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CopyDBParameterGroupAsync(ctx workflow.Context, input *rds.CopyDBParameterGroupInput) *CopyDBParameterGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CopyDBParameterGroup", input)
	return &CopyDBParameterGroupFuture{Future: future}
}

func (a *stub) CopyDBSnapshot(ctx workflow.Context, input *rds.CopyDBSnapshotInput) (*rds.CopyDBSnapshotOutput, error) {
	var output rds.CopyDBSnapshotOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CopyDBSnapshot", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CopyDBSnapshotAsync(ctx workflow.Context, input *rds.CopyDBSnapshotInput) *CopyDBSnapshotFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CopyDBSnapshot", input)
	return &CopyDBSnapshotFuture{Future: future}
}

func (a *stub) CopyOptionGroup(ctx workflow.Context, input *rds.CopyOptionGroupInput) (*rds.CopyOptionGroupOutput, error) {
	var output rds.CopyOptionGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CopyOptionGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CopyOptionGroupAsync(ctx workflow.Context, input *rds.CopyOptionGroupInput) *CopyOptionGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CopyOptionGroup", input)
	return &CopyOptionGroupFuture{Future: future}
}

func (a *stub) CreateCustomAvailabilityZone(ctx workflow.Context, input *rds.CreateCustomAvailabilityZoneInput) (*rds.CreateCustomAvailabilityZoneOutput, error) {
	var output rds.CreateCustomAvailabilityZoneOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateCustomAvailabilityZone", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateCustomAvailabilityZoneAsync(ctx workflow.Context, input *rds.CreateCustomAvailabilityZoneInput) *CreateCustomAvailabilityZoneFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateCustomAvailabilityZone", input)
	return &CreateCustomAvailabilityZoneFuture{Future: future}
}

func (a *stub) CreateDBCluster(ctx workflow.Context, input *rds.CreateDBClusterInput) (*rds.CreateDBClusterOutput, error) {
	var output rds.CreateDBClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDBClusterAsync(ctx workflow.Context, input *rds.CreateDBClusterInput) *CreateDBClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBCluster", input)
	return &CreateDBClusterFuture{Future: future}
}

func (a *stub) CreateDBClusterEndpoint(ctx workflow.Context, input *rds.CreateDBClusterEndpointInput) (*rds.CreateDBClusterEndpointOutput, error) {
	var output rds.CreateDBClusterEndpointOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBClusterEndpoint", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDBClusterEndpointAsync(ctx workflow.Context, input *rds.CreateDBClusterEndpointInput) *CreateDBClusterEndpointFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBClusterEndpoint", input)
	return &CreateDBClusterEndpointFuture{Future: future}
}

func (a *stub) CreateDBClusterParameterGroup(ctx workflow.Context, input *rds.CreateDBClusterParameterGroupInput) (*rds.CreateDBClusterParameterGroupOutput, error) {
	var output rds.CreateDBClusterParameterGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBClusterParameterGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDBClusterParameterGroupAsync(ctx workflow.Context, input *rds.CreateDBClusterParameterGroupInput) *CreateDBClusterParameterGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBClusterParameterGroup", input)
	return &CreateDBClusterParameterGroupFuture{Future: future}
}

func (a *stub) CreateDBClusterSnapshot(ctx workflow.Context, input *rds.CreateDBClusterSnapshotInput) (*rds.CreateDBClusterSnapshotOutput, error) {
	var output rds.CreateDBClusterSnapshotOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBClusterSnapshot", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDBClusterSnapshotAsync(ctx workflow.Context, input *rds.CreateDBClusterSnapshotInput) *CreateDBClusterSnapshotFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBClusterSnapshot", input)
	return &CreateDBClusterSnapshotFuture{Future: future}
}

func (a *stub) CreateDBInstance(ctx workflow.Context, input *rds.CreateDBInstanceInput) (*rds.CreateDBInstanceOutput, error) {
	var output rds.CreateDBInstanceOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBInstance", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDBInstanceAsync(ctx workflow.Context, input *rds.CreateDBInstanceInput) *CreateDBInstanceFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBInstance", input)
	return &CreateDBInstanceFuture{Future: future}
}

func (a *stub) CreateDBInstanceReadReplica(ctx workflow.Context, input *rds.CreateDBInstanceReadReplicaInput) (*rds.CreateDBInstanceReadReplicaOutput, error) {
	var output rds.CreateDBInstanceReadReplicaOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBInstanceReadReplica", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDBInstanceReadReplicaAsync(ctx workflow.Context, input *rds.CreateDBInstanceReadReplicaInput) *CreateDBInstanceReadReplicaFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBInstanceReadReplica", input)
	return &CreateDBInstanceReadReplicaFuture{Future: future}
}

func (a *stub) CreateDBParameterGroup(ctx workflow.Context, input *rds.CreateDBParameterGroupInput) (*rds.CreateDBParameterGroupOutput, error) {
	var output rds.CreateDBParameterGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBParameterGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDBParameterGroupAsync(ctx workflow.Context, input *rds.CreateDBParameterGroupInput) *CreateDBParameterGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBParameterGroup", input)
	return &CreateDBParameterGroupFuture{Future: future}
}

func (a *stub) CreateDBProxy(ctx workflow.Context, input *rds.CreateDBProxyInput) (*rds.CreateDBProxyOutput, error) {
	var output rds.CreateDBProxyOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBProxy", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDBProxyAsync(ctx workflow.Context, input *rds.CreateDBProxyInput) *CreateDBProxyFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBProxy", input)
	return &CreateDBProxyFuture{Future: future}
}

func (a *stub) CreateDBSecurityGroup(ctx workflow.Context, input *rds.CreateDBSecurityGroupInput) (*rds.CreateDBSecurityGroupOutput, error) {
	var output rds.CreateDBSecurityGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBSecurityGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDBSecurityGroupAsync(ctx workflow.Context, input *rds.CreateDBSecurityGroupInput) *CreateDBSecurityGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBSecurityGroup", input)
	return &CreateDBSecurityGroupFuture{Future: future}
}

func (a *stub) CreateDBSnapshot(ctx workflow.Context, input *rds.CreateDBSnapshotInput) (*rds.CreateDBSnapshotOutput, error) {
	var output rds.CreateDBSnapshotOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBSnapshot", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDBSnapshotAsync(ctx workflow.Context, input *rds.CreateDBSnapshotInput) *CreateDBSnapshotFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBSnapshot", input)
	return &CreateDBSnapshotFuture{Future: future}
}

func (a *stub) CreateDBSubnetGroup(ctx workflow.Context, input *rds.CreateDBSubnetGroupInput) (*rds.CreateDBSubnetGroupOutput, error) {
	var output rds.CreateDBSubnetGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBSubnetGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDBSubnetGroupAsync(ctx workflow.Context, input *rds.CreateDBSubnetGroupInput) *CreateDBSubnetGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateDBSubnetGroup", input)
	return &CreateDBSubnetGroupFuture{Future: future}
}

func (a *stub) CreateEventSubscription(ctx workflow.Context, input *rds.CreateEventSubscriptionInput) (*rds.CreateEventSubscriptionOutput, error) {
	var output rds.CreateEventSubscriptionOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateEventSubscription", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateEventSubscriptionAsync(ctx workflow.Context, input *rds.CreateEventSubscriptionInput) *CreateEventSubscriptionFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateEventSubscription", input)
	return &CreateEventSubscriptionFuture{Future: future}
}

func (a *stub) CreateGlobalCluster(ctx workflow.Context, input *rds.CreateGlobalClusterInput) (*rds.CreateGlobalClusterOutput, error) {
	var output rds.CreateGlobalClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateGlobalCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateGlobalClusterAsync(ctx workflow.Context, input *rds.CreateGlobalClusterInput) *CreateGlobalClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateGlobalCluster", input)
	return &CreateGlobalClusterFuture{Future: future}
}

func (a *stub) CreateOptionGroup(ctx workflow.Context, input *rds.CreateOptionGroupInput) (*rds.CreateOptionGroupOutput, error) {
	var output rds.CreateOptionGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-CreateOptionGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateOptionGroupAsync(ctx workflow.Context, input *rds.CreateOptionGroupInput) *CreateOptionGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-CreateOptionGroup", input)
	return &CreateOptionGroupFuture{Future: future}
}

func (a *stub) DeleteCustomAvailabilityZone(ctx workflow.Context, input *rds.DeleteCustomAvailabilityZoneInput) (*rds.DeleteCustomAvailabilityZoneOutput, error) {
	var output rds.DeleteCustomAvailabilityZoneOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteCustomAvailabilityZone", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteCustomAvailabilityZoneAsync(ctx workflow.Context, input *rds.DeleteCustomAvailabilityZoneInput) *DeleteCustomAvailabilityZoneFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteCustomAvailabilityZone", input)
	return &DeleteCustomAvailabilityZoneFuture{Future: future}
}

func (a *stub) DeleteDBCluster(ctx workflow.Context, input *rds.DeleteDBClusterInput) (*rds.DeleteDBClusterOutput, error) {
	var output rds.DeleteDBClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDBClusterAsync(ctx workflow.Context, input *rds.DeleteDBClusterInput) *DeleteDBClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBCluster", input)
	return &DeleteDBClusterFuture{Future: future}
}

func (a *stub) DeleteDBClusterEndpoint(ctx workflow.Context, input *rds.DeleteDBClusterEndpointInput) (*rds.DeleteDBClusterEndpointOutput, error) {
	var output rds.DeleteDBClusterEndpointOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBClusterEndpoint", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDBClusterEndpointAsync(ctx workflow.Context, input *rds.DeleteDBClusterEndpointInput) *DeleteDBClusterEndpointFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBClusterEndpoint", input)
	return &DeleteDBClusterEndpointFuture{Future: future}
}

func (a *stub) DeleteDBClusterParameterGroup(ctx workflow.Context, input *rds.DeleteDBClusterParameterGroupInput) (*rds.DeleteDBClusterParameterGroupOutput, error) {
	var output rds.DeleteDBClusterParameterGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBClusterParameterGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDBClusterParameterGroupAsync(ctx workflow.Context, input *rds.DeleteDBClusterParameterGroupInput) *DeleteDBClusterParameterGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBClusterParameterGroup", input)
	return &DeleteDBClusterParameterGroupFuture{Future: future}
}

func (a *stub) DeleteDBClusterSnapshot(ctx workflow.Context, input *rds.DeleteDBClusterSnapshotInput) (*rds.DeleteDBClusterSnapshotOutput, error) {
	var output rds.DeleteDBClusterSnapshotOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBClusterSnapshot", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDBClusterSnapshotAsync(ctx workflow.Context, input *rds.DeleteDBClusterSnapshotInput) *DeleteDBClusterSnapshotFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBClusterSnapshot", input)
	return &DeleteDBClusterSnapshotFuture{Future: future}
}

func (a *stub) DeleteDBInstance(ctx workflow.Context, input *rds.DeleteDBInstanceInput) (*rds.DeleteDBInstanceOutput, error) {
	var output rds.DeleteDBInstanceOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBInstance", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDBInstanceAsync(ctx workflow.Context, input *rds.DeleteDBInstanceInput) *DeleteDBInstanceFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBInstance", input)
	return &DeleteDBInstanceFuture{Future: future}
}

func (a *stub) DeleteDBInstanceAutomatedBackup(ctx workflow.Context, input *rds.DeleteDBInstanceAutomatedBackupInput) (*rds.DeleteDBInstanceAutomatedBackupOutput, error) {
	var output rds.DeleteDBInstanceAutomatedBackupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBInstanceAutomatedBackup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDBInstanceAutomatedBackupAsync(ctx workflow.Context, input *rds.DeleteDBInstanceAutomatedBackupInput) *DeleteDBInstanceAutomatedBackupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBInstanceAutomatedBackup", input)
	return &DeleteDBInstanceAutomatedBackupFuture{Future: future}
}

func (a *stub) DeleteDBParameterGroup(ctx workflow.Context, input *rds.DeleteDBParameterGroupInput) (*rds.DeleteDBParameterGroupOutput, error) {
	var output rds.DeleteDBParameterGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBParameterGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDBParameterGroupAsync(ctx workflow.Context, input *rds.DeleteDBParameterGroupInput) *DeleteDBParameterGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBParameterGroup", input)
	return &DeleteDBParameterGroupFuture{Future: future}
}

func (a *stub) DeleteDBProxy(ctx workflow.Context, input *rds.DeleteDBProxyInput) (*rds.DeleteDBProxyOutput, error) {
	var output rds.DeleteDBProxyOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBProxy", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDBProxyAsync(ctx workflow.Context, input *rds.DeleteDBProxyInput) *DeleteDBProxyFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBProxy", input)
	return &DeleteDBProxyFuture{Future: future}
}

func (a *stub) DeleteDBSecurityGroup(ctx workflow.Context, input *rds.DeleteDBSecurityGroupInput) (*rds.DeleteDBSecurityGroupOutput, error) {
	var output rds.DeleteDBSecurityGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBSecurityGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDBSecurityGroupAsync(ctx workflow.Context, input *rds.DeleteDBSecurityGroupInput) *DeleteDBSecurityGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBSecurityGroup", input)
	return &DeleteDBSecurityGroupFuture{Future: future}
}

func (a *stub) DeleteDBSnapshot(ctx workflow.Context, input *rds.DeleteDBSnapshotInput) (*rds.DeleteDBSnapshotOutput, error) {
	var output rds.DeleteDBSnapshotOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBSnapshot", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDBSnapshotAsync(ctx workflow.Context, input *rds.DeleteDBSnapshotInput) *DeleteDBSnapshotFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBSnapshot", input)
	return &DeleteDBSnapshotFuture{Future: future}
}

func (a *stub) DeleteDBSubnetGroup(ctx workflow.Context, input *rds.DeleteDBSubnetGroupInput) (*rds.DeleteDBSubnetGroupOutput, error) {
	var output rds.DeleteDBSubnetGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBSubnetGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDBSubnetGroupAsync(ctx workflow.Context, input *rds.DeleteDBSubnetGroupInput) *DeleteDBSubnetGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteDBSubnetGroup", input)
	return &DeleteDBSubnetGroupFuture{Future: future}
}

func (a *stub) DeleteEventSubscription(ctx workflow.Context, input *rds.DeleteEventSubscriptionInput) (*rds.DeleteEventSubscriptionOutput, error) {
	var output rds.DeleteEventSubscriptionOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteEventSubscription", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteEventSubscriptionAsync(ctx workflow.Context, input *rds.DeleteEventSubscriptionInput) *DeleteEventSubscriptionFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteEventSubscription", input)
	return &DeleteEventSubscriptionFuture{Future: future}
}

func (a *stub) DeleteGlobalCluster(ctx workflow.Context, input *rds.DeleteGlobalClusterInput) (*rds.DeleteGlobalClusterOutput, error) {
	var output rds.DeleteGlobalClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteGlobalCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteGlobalClusterAsync(ctx workflow.Context, input *rds.DeleteGlobalClusterInput) *DeleteGlobalClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteGlobalCluster", input)
	return &DeleteGlobalClusterFuture{Future: future}
}

func (a *stub) DeleteInstallationMedia(ctx workflow.Context, input *rds.DeleteInstallationMediaInput) (*rds.DeleteInstallationMediaOutput, error) {
	var output rds.DeleteInstallationMediaOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteInstallationMedia", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteInstallationMediaAsync(ctx workflow.Context, input *rds.DeleteInstallationMediaInput) *DeleteInstallationMediaFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteInstallationMedia", input)
	return &DeleteInstallationMediaFuture{Future: future}
}

func (a *stub) DeleteOptionGroup(ctx workflow.Context, input *rds.DeleteOptionGroupInput) (*rds.DeleteOptionGroupOutput, error) {
	var output rds.DeleteOptionGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeleteOptionGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteOptionGroupAsync(ctx workflow.Context, input *rds.DeleteOptionGroupInput) *DeleteOptionGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeleteOptionGroup", input)
	return &DeleteOptionGroupFuture{Future: future}
}

func (a *stub) DeregisterDBProxyTargets(ctx workflow.Context, input *rds.DeregisterDBProxyTargetsInput) (*rds.DeregisterDBProxyTargetsOutput, error) {
	var output rds.DeregisterDBProxyTargetsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DeregisterDBProxyTargets", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeregisterDBProxyTargetsAsync(ctx workflow.Context, input *rds.DeregisterDBProxyTargetsInput) *DeregisterDBProxyTargetsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DeregisterDBProxyTargets", input)
	return &DeregisterDBProxyTargetsFuture{Future: future}
}

func (a *stub) DescribeAccountAttributes(ctx workflow.Context, input *rds.DescribeAccountAttributesInput) (*rds.DescribeAccountAttributesOutput, error) {
	var output rds.DescribeAccountAttributesOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeAccountAttributes", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeAccountAttributesAsync(ctx workflow.Context, input *rds.DescribeAccountAttributesInput) *DescribeAccountAttributesFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeAccountAttributes", input)
	return &DescribeAccountAttributesFuture{Future: future}
}

func (a *stub) DescribeCertificates(ctx workflow.Context, input *rds.DescribeCertificatesInput) (*rds.DescribeCertificatesOutput, error) {
	var output rds.DescribeCertificatesOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeCertificates", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeCertificatesAsync(ctx workflow.Context, input *rds.DescribeCertificatesInput) *DescribeCertificatesFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeCertificates", input)
	return &DescribeCertificatesFuture{Future: future}
}

func (a *stub) DescribeCustomAvailabilityZones(ctx workflow.Context, input *rds.DescribeCustomAvailabilityZonesInput) (*rds.DescribeCustomAvailabilityZonesOutput, error) {
	var output rds.DescribeCustomAvailabilityZonesOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeCustomAvailabilityZones", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeCustomAvailabilityZonesAsync(ctx workflow.Context, input *rds.DescribeCustomAvailabilityZonesInput) *DescribeCustomAvailabilityZonesFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeCustomAvailabilityZones", input)
	return &DescribeCustomAvailabilityZonesFuture{Future: future}
}

func (a *stub) DescribeDBClusterBacktracks(ctx workflow.Context, input *rds.DescribeDBClusterBacktracksInput) (*rds.DescribeDBClusterBacktracksOutput, error) {
	var output rds.DescribeDBClusterBacktracksOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusterBacktracks", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBClusterBacktracksAsync(ctx workflow.Context, input *rds.DescribeDBClusterBacktracksInput) *DescribeDBClusterBacktracksFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusterBacktracks", input)
	return &DescribeDBClusterBacktracksFuture{Future: future}
}

func (a *stub) DescribeDBClusterEndpoints(ctx workflow.Context, input *rds.DescribeDBClusterEndpointsInput) (*rds.DescribeDBClusterEndpointsOutput, error) {
	var output rds.DescribeDBClusterEndpointsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusterEndpoints", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBClusterEndpointsAsync(ctx workflow.Context, input *rds.DescribeDBClusterEndpointsInput) *DescribeDBClusterEndpointsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusterEndpoints", input)
	return &DescribeDBClusterEndpointsFuture{Future: future}
}

func (a *stub) DescribeDBClusterParameterGroups(ctx workflow.Context, input *rds.DescribeDBClusterParameterGroupsInput) (*rds.DescribeDBClusterParameterGroupsOutput, error) {
	var output rds.DescribeDBClusterParameterGroupsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusterParameterGroups", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBClusterParameterGroupsAsync(ctx workflow.Context, input *rds.DescribeDBClusterParameterGroupsInput) *DescribeDBClusterParameterGroupsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusterParameterGroups", input)
	return &DescribeDBClusterParameterGroupsFuture{Future: future}
}

func (a *stub) DescribeDBClusterParameters(ctx workflow.Context, input *rds.DescribeDBClusterParametersInput) (*rds.DescribeDBClusterParametersOutput, error) {
	var output rds.DescribeDBClusterParametersOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusterParameters", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBClusterParametersAsync(ctx workflow.Context, input *rds.DescribeDBClusterParametersInput) *DescribeDBClusterParametersFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusterParameters", input)
	return &DescribeDBClusterParametersFuture{Future: future}
}

func (a *stub) DescribeDBClusterSnapshotAttributes(ctx workflow.Context, input *rds.DescribeDBClusterSnapshotAttributesInput) (*rds.DescribeDBClusterSnapshotAttributesOutput, error) {
	var output rds.DescribeDBClusterSnapshotAttributesOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusterSnapshotAttributes", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBClusterSnapshotAttributesAsync(ctx workflow.Context, input *rds.DescribeDBClusterSnapshotAttributesInput) *DescribeDBClusterSnapshotAttributesFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusterSnapshotAttributes", input)
	return &DescribeDBClusterSnapshotAttributesFuture{Future: future}
}

func (a *stub) DescribeDBClusterSnapshots(ctx workflow.Context, input *rds.DescribeDBClusterSnapshotsInput) (*rds.DescribeDBClusterSnapshotsOutput, error) {
	var output rds.DescribeDBClusterSnapshotsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusterSnapshots", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBClusterSnapshotsAsync(ctx workflow.Context, input *rds.DescribeDBClusterSnapshotsInput) *DescribeDBClusterSnapshotsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusterSnapshots", input)
	return &DescribeDBClusterSnapshotsFuture{Future: future}
}

func (a *stub) DescribeDBClusters(ctx workflow.Context, input *rds.DescribeDBClustersInput) (*rds.DescribeDBClustersOutput, error) {
	var output rds.DescribeDBClustersOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusters", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBClustersAsync(ctx workflow.Context, input *rds.DescribeDBClustersInput) *DescribeDBClustersFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBClusters", input)
	return &DescribeDBClustersFuture{Future: future}
}

func (a *stub) DescribeDBEngineVersions(ctx workflow.Context, input *rds.DescribeDBEngineVersionsInput) (*rds.DescribeDBEngineVersionsOutput, error) {
	var output rds.DescribeDBEngineVersionsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBEngineVersions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBEngineVersionsAsync(ctx workflow.Context, input *rds.DescribeDBEngineVersionsInput) *DescribeDBEngineVersionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBEngineVersions", input)
	return &DescribeDBEngineVersionsFuture{Future: future}
}

func (a *stub) DescribeDBInstanceAutomatedBackups(ctx workflow.Context, input *rds.DescribeDBInstanceAutomatedBackupsInput) (*rds.DescribeDBInstanceAutomatedBackupsOutput, error) {
	var output rds.DescribeDBInstanceAutomatedBackupsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBInstanceAutomatedBackups", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBInstanceAutomatedBackupsAsync(ctx workflow.Context, input *rds.DescribeDBInstanceAutomatedBackupsInput) *DescribeDBInstanceAutomatedBackupsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBInstanceAutomatedBackups", input)
	return &DescribeDBInstanceAutomatedBackupsFuture{Future: future}
}

func (a *stub) DescribeDBInstances(ctx workflow.Context, input *rds.DescribeDBInstancesInput) (*rds.DescribeDBInstancesOutput, error) {
	var output rds.DescribeDBInstancesOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBInstances", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBInstancesAsync(ctx workflow.Context, input *rds.DescribeDBInstancesInput) *DescribeDBInstancesFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBInstances", input)
	return &DescribeDBInstancesFuture{Future: future}
}

func (a *stub) DescribeDBLogFiles(ctx workflow.Context, input *rds.DescribeDBLogFilesInput) (*rds.DescribeDBLogFilesOutput, error) {
	var output rds.DescribeDBLogFilesOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBLogFiles", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBLogFilesAsync(ctx workflow.Context, input *rds.DescribeDBLogFilesInput) *DescribeDBLogFilesFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBLogFiles", input)
	return &DescribeDBLogFilesFuture{Future: future}
}

func (a *stub) DescribeDBParameterGroups(ctx workflow.Context, input *rds.DescribeDBParameterGroupsInput) (*rds.DescribeDBParameterGroupsOutput, error) {
	var output rds.DescribeDBParameterGroupsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBParameterGroups", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBParameterGroupsAsync(ctx workflow.Context, input *rds.DescribeDBParameterGroupsInput) *DescribeDBParameterGroupsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBParameterGroups", input)
	return &DescribeDBParameterGroupsFuture{Future: future}
}

func (a *stub) DescribeDBParameters(ctx workflow.Context, input *rds.DescribeDBParametersInput) (*rds.DescribeDBParametersOutput, error) {
	var output rds.DescribeDBParametersOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBParameters", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBParametersAsync(ctx workflow.Context, input *rds.DescribeDBParametersInput) *DescribeDBParametersFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBParameters", input)
	return &DescribeDBParametersFuture{Future: future}
}

func (a *stub) DescribeDBProxies(ctx workflow.Context, input *rds.DescribeDBProxiesInput) (*rds.DescribeDBProxiesOutput, error) {
	var output rds.DescribeDBProxiesOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBProxies", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBProxiesAsync(ctx workflow.Context, input *rds.DescribeDBProxiesInput) *DescribeDBProxiesFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBProxies", input)
	return &DescribeDBProxiesFuture{Future: future}
}

func (a *stub) DescribeDBProxyTargetGroups(ctx workflow.Context, input *rds.DescribeDBProxyTargetGroupsInput) (*rds.DescribeDBProxyTargetGroupsOutput, error) {
	var output rds.DescribeDBProxyTargetGroupsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBProxyTargetGroups", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBProxyTargetGroupsAsync(ctx workflow.Context, input *rds.DescribeDBProxyTargetGroupsInput) *DescribeDBProxyTargetGroupsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBProxyTargetGroups", input)
	return &DescribeDBProxyTargetGroupsFuture{Future: future}
}

func (a *stub) DescribeDBProxyTargets(ctx workflow.Context, input *rds.DescribeDBProxyTargetsInput) (*rds.DescribeDBProxyTargetsOutput, error) {
	var output rds.DescribeDBProxyTargetsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBProxyTargets", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBProxyTargetsAsync(ctx workflow.Context, input *rds.DescribeDBProxyTargetsInput) *DescribeDBProxyTargetsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBProxyTargets", input)
	return &DescribeDBProxyTargetsFuture{Future: future}
}

func (a *stub) DescribeDBSecurityGroups(ctx workflow.Context, input *rds.DescribeDBSecurityGroupsInput) (*rds.DescribeDBSecurityGroupsOutput, error) {
	var output rds.DescribeDBSecurityGroupsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBSecurityGroups", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBSecurityGroupsAsync(ctx workflow.Context, input *rds.DescribeDBSecurityGroupsInput) *DescribeDBSecurityGroupsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBSecurityGroups", input)
	return &DescribeDBSecurityGroupsFuture{Future: future}
}

func (a *stub) DescribeDBSnapshotAttributes(ctx workflow.Context, input *rds.DescribeDBSnapshotAttributesInput) (*rds.DescribeDBSnapshotAttributesOutput, error) {
	var output rds.DescribeDBSnapshotAttributesOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBSnapshotAttributes", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBSnapshotAttributesAsync(ctx workflow.Context, input *rds.DescribeDBSnapshotAttributesInput) *DescribeDBSnapshotAttributesFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBSnapshotAttributes", input)
	return &DescribeDBSnapshotAttributesFuture{Future: future}
}

func (a *stub) DescribeDBSnapshots(ctx workflow.Context, input *rds.DescribeDBSnapshotsInput) (*rds.DescribeDBSnapshotsOutput, error) {
	var output rds.DescribeDBSnapshotsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBSnapshots", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBSnapshotsAsync(ctx workflow.Context, input *rds.DescribeDBSnapshotsInput) *DescribeDBSnapshotsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBSnapshots", input)
	return &DescribeDBSnapshotsFuture{Future: future}
}

func (a *stub) DescribeDBSubnetGroups(ctx workflow.Context, input *rds.DescribeDBSubnetGroupsInput) (*rds.DescribeDBSubnetGroupsOutput, error) {
	var output rds.DescribeDBSubnetGroupsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBSubnetGroups", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDBSubnetGroupsAsync(ctx workflow.Context, input *rds.DescribeDBSubnetGroupsInput) *DescribeDBSubnetGroupsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeDBSubnetGroups", input)
	return &DescribeDBSubnetGroupsFuture{Future: future}
}

func (a *stub) DescribeEngineDefaultClusterParameters(ctx workflow.Context, input *rds.DescribeEngineDefaultClusterParametersInput) (*rds.DescribeEngineDefaultClusterParametersOutput, error) {
	var output rds.DescribeEngineDefaultClusterParametersOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeEngineDefaultClusterParameters", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeEngineDefaultClusterParametersAsync(ctx workflow.Context, input *rds.DescribeEngineDefaultClusterParametersInput) *DescribeEngineDefaultClusterParametersFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeEngineDefaultClusterParameters", input)
	return &DescribeEngineDefaultClusterParametersFuture{Future: future}
}

func (a *stub) DescribeEngineDefaultParameters(ctx workflow.Context, input *rds.DescribeEngineDefaultParametersInput) (*rds.DescribeEngineDefaultParametersOutput, error) {
	var output rds.DescribeEngineDefaultParametersOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeEngineDefaultParameters", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeEngineDefaultParametersAsync(ctx workflow.Context, input *rds.DescribeEngineDefaultParametersInput) *DescribeEngineDefaultParametersFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeEngineDefaultParameters", input)
	return &DescribeEngineDefaultParametersFuture{Future: future}
}

func (a *stub) DescribeEventCategories(ctx workflow.Context, input *rds.DescribeEventCategoriesInput) (*rds.DescribeEventCategoriesOutput, error) {
	var output rds.DescribeEventCategoriesOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeEventCategories", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeEventCategoriesAsync(ctx workflow.Context, input *rds.DescribeEventCategoriesInput) *DescribeEventCategoriesFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeEventCategories", input)
	return &DescribeEventCategoriesFuture{Future: future}
}

func (a *stub) DescribeEventSubscriptions(ctx workflow.Context, input *rds.DescribeEventSubscriptionsInput) (*rds.DescribeEventSubscriptionsOutput, error) {
	var output rds.DescribeEventSubscriptionsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeEventSubscriptions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeEventSubscriptionsAsync(ctx workflow.Context, input *rds.DescribeEventSubscriptionsInput) *DescribeEventSubscriptionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeEventSubscriptions", input)
	return &DescribeEventSubscriptionsFuture{Future: future}
}

func (a *stub) DescribeEvents(ctx workflow.Context, input *rds.DescribeEventsInput) (*rds.DescribeEventsOutput, error) {
	var output rds.DescribeEventsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeEvents", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeEventsAsync(ctx workflow.Context, input *rds.DescribeEventsInput) *DescribeEventsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeEvents", input)
	return &DescribeEventsFuture{Future: future}
}

func (a *stub) DescribeExportTasks(ctx workflow.Context, input *rds.DescribeExportTasksInput) (*rds.DescribeExportTasksOutput, error) {
	var output rds.DescribeExportTasksOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeExportTasks", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeExportTasksAsync(ctx workflow.Context, input *rds.DescribeExportTasksInput) *DescribeExportTasksFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeExportTasks", input)
	return &DescribeExportTasksFuture{Future: future}
}

func (a *stub) DescribeGlobalClusters(ctx workflow.Context, input *rds.DescribeGlobalClustersInput) (*rds.DescribeGlobalClustersOutput, error) {
	var output rds.DescribeGlobalClustersOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeGlobalClusters", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeGlobalClustersAsync(ctx workflow.Context, input *rds.DescribeGlobalClustersInput) *DescribeGlobalClustersFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeGlobalClusters", input)
	return &DescribeGlobalClustersFuture{Future: future}
}

func (a *stub) DescribeInstallationMedia(ctx workflow.Context, input *rds.DescribeInstallationMediaInput) (*rds.DescribeInstallationMediaOutput, error) {
	var output rds.DescribeInstallationMediaOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeInstallationMedia", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeInstallationMediaAsync(ctx workflow.Context, input *rds.DescribeInstallationMediaInput) *DescribeInstallationMediaFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeInstallationMedia", input)
	return &DescribeInstallationMediaFuture{Future: future}
}

func (a *stub) DescribeOptionGroupOptions(ctx workflow.Context, input *rds.DescribeOptionGroupOptionsInput) (*rds.DescribeOptionGroupOptionsOutput, error) {
	var output rds.DescribeOptionGroupOptionsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeOptionGroupOptions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeOptionGroupOptionsAsync(ctx workflow.Context, input *rds.DescribeOptionGroupOptionsInput) *DescribeOptionGroupOptionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeOptionGroupOptions", input)
	return &DescribeOptionGroupOptionsFuture{Future: future}
}

func (a *stub) DescribeOptionGroups(ctx workflow.Context, input *rds.DescribeOptionGroupsInput) (*rds.DescribeOptionGroupsOutput, error) {
	var output rds.DescribeOptionGroupsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeOptionGroups", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeOptionGroupsAsync(ctx workflow.Context, input *rds.DescribeOptionGroupsInput) *DescribeOptionGroupsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeOptionGroups", input)
	return &DescribeOptionGroupsFuture{Future: future}
}

func (a *stub) DescribeOrderableDBInstanceOptions(ctx workflow.Context, input *rds.DescribeOrderableDBInstanceOptionsInput) (*rds.DescribeOrderableDBInstanceOptionsOutput, error) {
	var output rds.DescribeOrderableDBInstanceOptionsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeOrderableDBInstanceOptions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeOrderableDBInstanceOptionsAsync(ctx workflow.Context, input *rds.DescribeOrderableDBInstanceOptionsInput) *DescribeOrderableDBInstanceOptionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeOrderableDBInstanceOptions", input)
	return &DescribeOrderableDBInstanceOptionsFuture{Future: future}
}

func (a *stub) DescribePendingMaintenanceActions(ctx workflow.Context, input *rds.DescribePendingMaintenanceActionsInput) (*rds.DescribePendingMaintenanceActionsOutput, error) {
	var output rds.DescribePendingMaintenanceActionsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribePendingMaintenanceActions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribePendingMaintenanceActionsAsync(ctx workflow.Context, input *rds.DescribePendingMaintenanceActionsInput) *DescribePendingMaintenanceActionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribePendingMaintenanceActions", input)
	return &DescribePendingMaintenanceActionsFuture{Future: future}
}

func (a *stub) DescribeReservedDBInstances(ctx workflow.Context, input *rds.DescribeReservedDBInstancesInput) (*rds.DescribeReservedDBInstancesOutput, error) {
	var output rds.DescribeReservedDBInstancesOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeReservedDBInstances", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeReservedDBInstancesAsync(ctx workflow.Context, input *rds.DescribeReservedDBInstancesInput) *DescribeReservedDBInstancesFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeReservedDBInstances", input)
	return &DescribeReservedDBInstancesFuture{Future: future}
}

func (a *stub) DescribeReservedDBInstancesOfferings(ctx workflow.Context, input *rds.DescribeReservedDBInstancesOfferingsInput) (*rds.DescribeReservedDBInstancesOfferingsOutput, error) {
	var output rds.DescribeReservedDBInstancesOfferingsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeReservedDBInstancesOfferings", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeReservedDBInstancesOfferingsAsync(ctx workflow.Context, input *rds.DescribeReservedDBInstancesOfferingsInput) *DescribeReservedDBInstancesOfferingsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeReservedDBInstancesOfferings", input)
	return &DescribeReservedDBInstancesOfferingsFuture{Future: future}
}

func (a *stub) DescribeSourceRegions(ctx workflow.Context, input *rds.DescribeSourceRegionsInput) (*rds.DescribeSourceRegionsOutput, error) {
	var output rds.DescribeSourceRegionsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeSourceRegions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeSourceRegionsAsync(ctx workflow.Context, input *rds.DescribeSourceRegionsInput) *DescribeSourceRegionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeSourceRegions", input)
	return &DescribeSourceRegionsFuture{Future: future}
}

func (a *stub) DescribeValidDBInstanceModifications(ctx workflow.Context, input *rds.DescribeValidDBInstanceModificationsInput) (*rds.DescribeValidDBInstanceModificationsOutput, error) {
	var output rds.DescribeValidDBInstanceModificationsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DescribeValidDBInstanceModifications", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeValidDBInstanceModificationsAsync(ctx workflow.Context, input *rds.DescribeValidDBInstanceModificationsInput) *DescribeValidDBInstanceModificationsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DescribeValidDBInstanceModifications", input)
	return &DescribeValidDBInstanceModificationsFuture{Future: future}
}

func (a *stub) DownloadDBLogFilePortion(ctx workflow.Context, input *rds.DownloadDBLogFilePortionInput) (*rds.DownloadDBLogFilePortionOutput, error) {
	var output rds.DownloadDBLogFilePortionOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-DownloadDBLogFilePortion", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DownloadDBLogFilePortionAsync(ctx workflow.Context, input *rds.DownloadDBLogFilePortionInput) *DownloadDBLogFilePortionFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-DownloadDBLogFilePortion", input)
	return &DownloadDBLogFilePortionFuture{Future: future}
}

func (a *stub) FailoverDBCluster(ctx workflow.Context, input *rds.FailoverDBClusterInput) (*rds.FailoverDBClusterOutput, error) {
	var output rds.FailoverDBClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-FailoverDBCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) FailoverDBClusterAsync(ctx workflow.Context, input *rds.FailoverDBClusterInput) *FailoverDBClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-FailoverDBCluster", input)
	return &FailoverDBClusterFuture{Future: future}
}

func (a *stub) ImportInstallationMedia(ctx workflow.Context, input *rds.ImportInstallationMediaInput) (*rds.ImportInstallationMediaOutput, error) {
	var output rds.ImportInstallationMediaOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ImportInstallationMedia", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ImportInstallationMediaAsync(ctx workflow.Context, input *rds.ImportInstallationMediaInput) *ImportInstallationMediaFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ImportInstallationMedia", input)
	return &ImportInstallationMediaFuture{Future: future}
}

func (a *stub) ListTagsForResource(ctx workflow.Context, input *rds.ListTagsForResourceInput) (*rds.ListTagsForResourceOutput, error) {
	var output rds.ListTagsForResourceOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ListTagsForResource", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListTagsForResourceAsync(ctx workflow.Context, input *rds.ListTagsForResourceInput) *ListTagsForResourceFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ListTagsForResource", input)
	return &ListTagsForResourceFuture{Future: future}
}

func (a *stub) ModifyCertificates(ctx workflow.Context, input *rds.ModifyCertificatesInput) (*rds.ModifyCertificatesOutput, error) {
	var output rds.ModifyCertificatesOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyCertificates", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyCertificatesAsync(ctx workflow.Context, input *rds.ModifyCertificatesInput) *ModifyCertificatesFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyCertificates", input)
	return &ModifyCertificatesFuture{Future: future}
}

func (a *stub) ModifyCurrentDBClusterCapacity(ctx workflow.Context, input *rds.ModifyCurrentDBClusterCapacityInput) (*rds.ModifyCurrentDBClusterCapacityOutput, error) {
	var output rds.ModifyCurrentDBClusterCapacityOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyCurrentDBClusterCapacity", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyCurrentDBClusterCapacityAsync(ctx workflow.Context, input *rds.ModifyCurrentDBClusterCapacityInput) *ModifyCurrentDBClusterCapacityFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyCurrentDBClusterCapacity", input)
	return &ModifyCurrentDBClusterCapacityFuture{Future: future}
}

func (a *stub) ModifyDBCluster(ctx workflow.Context, input *rds.ModifyDBClusterInput) (*rds.ModifyDBClusterOutput, error) {
	var output rds.ModifyDBClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyDBClusterAsync(ctx workflow.Context, input *rds.ModifyDBClusterInput) *ModifyDBClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBCluster", input)
	return &ModifyDBClusterFuture{Future: future}
}

func (a *stub) ModifyDBClusterEndpoint(ctx workflow.Context, input *rds.ModifyDBClusterEndpointInput) (*rds.ModifyDBClusterEndpointOutput, error) {
	var output rds.ModifyDBClusterEndpointOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBClusterEndpoint", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyDBClusterEndpointAsync(ctx workflow.Context, input *rds.ModifyDBClusterEndpointInput) *ModifyDBClusterEndpointFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBClusterEndpoint", input)
	return &ModifyDBClusterEndpointFuture{Future: future}
}

func (a *stub) ModifyDBClusterParameterGroup(ctx workflow.Context, input *rds.ModifyDBClusterParameterGroupInput) (*rds.DBClusterParameterGroupNameMessage, error) {
	var output rds.DBClusterParameterGroupNameMessage
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBClusterParameterGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyDBClusterParameterGroupAsync(ctx workflow.Context, input *rds.ModifyDBClusterParameterGroupInput) *ModifyDBClusterParameterGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBClusterParameterGroup", input)
	return &ModifyDBClusterParameterGroupFuture{Future: future}
}

func (a *stub) ModifyDBClusterSnapshotAttribute(ctx workflow.Context, input *rds.ModifyDBClusterSnapshotAttributeInput) (*rds.ModifyDBClusterSnapshotAttributeOutput, error) {
	var output rds.ModifyDBClusterSnapshotAttributeOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBClusterSnapshotAttribute", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyDBClusterSnapshotAttributeAsync(ctx workflow.Context, input *rds.ModifyDBClusterSnapshotAttributeInput) *ModifyDBClusterSnapshotAttributeFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBClusterSnapshotAttribute", input)
	return &ModifyDBClusterSnapshotAttributeFuture{Future: future}
}

func (a *stub) ModifyDBInstance(ctx workflow.Context, input *rds.ModifyDBInstanceInput) (*rds.ModifyDBInstanceOutput, error) {
	var output rds.ModifyDBInstanceOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBInstance", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyDBInstanceAsync(ctx workflow.Context, input *rds.ModifyDBInstanceInput) *ModifyDBInstanceFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBInstance", input)
	return &ModifyDBInstanceFuture{Future: future}
}

func (a *stub) ModifyDBParameterGroup(ctx workflow.Context, input *rds.ModifyDBParameterGroupInput) (*rds.DBParameterGroupNameMessage, error) {
	var output rds.DBParameterGroupNameMessage
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBParameterGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyDBParameterGroupAsync(ctx workflow.Context, input *rds.ModifyDBParameterGroupInput) *ModifyDBParameterGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBParameterGroup", input)
	return &ModifyDBParameterGroupFuture{Future: future}
}

func (a *stub) ModifyDBProxy(ctx workflow.Context, input *rds.ModifyDBProxyInput) (*rds.ModifyDBProxyOutput, error) {
	var output rds.ModifyDBProxyOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBProxy", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyDBProxyAsync(ctx workflow.Context, input *rds.ModifyDBProxyInput) *ModifyDBProxyFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBProxy", input)
	return &ModifyDBProxyFuture{Future: future}
}

func (a *stub) ModifyDBProxyTargetGroup(ctx workflow.Context, input *rds.ModifyDBProxyTargetGroupInput) (*rds.ModifyDBProxyTargetGroupOutput, error) {
	var output rds.ModifyDBProxyTargetGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBProxyTargetGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyDBProxyTargetGroupAsync(ctx workflow.Context, input *rds.ModifyDBProxyTargetGroupInput) *ModifyDBProxyTargetGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBProxyTargetGroup", input)
	return &ModifyDBProxyTargetGroupFuture{Future: future}
}

func (a *stub) ModifyDBSnapshot(ctx workflow.Context, input *rds.ModifyDBSnapshotInput) (*rds.ModifyDBSnapshotOutput, error) {
	var output rds.ModifyDBSnapshotOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBSnapshot", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyDBSnapshotAsync(ctx workflow.Context, input *rds.ModifyDBSnapshotInput) *ModifyDBSnapshotFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBSnapshot", input)
	return &ModifyDBSnapshotFuture{Future: future}
}

func (a *stub) ModifyDBSnapshotAttribute(ctx workflow.Context, input *rds.ModifyDBSnapshotAttributeInput) (*rds.ModifyDBSnapshotAttributeOutput, error) {
	var output rds.ModifyDBSnapshotAttributeOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBSnapshotAttribute", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyDBSnapshotAttributeAsync(ctx workflow.Context, input *rds.ModifyDBSnapshotAttributeInput) *ModifyDBSnapshotAttributeFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBSnapshotAttribute", input)
	return &ModifyDBSnapshotAttributeFuture{Future: future}
}

func (a *stub) ModifyDBSubnetGroup(ctx workflow.Context, input *rds.ModifyDBSubnetGroupInput) (*rds.ModifyDBSubnetGroupOutput, error) {
	var output rds.ModifyDBSubnetGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBSubnetGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyDBSubnetGroupAsync(ctx workflow.Context, input *rds.ModifyDBSubnetGroupInput) *ModifyDBSubnetGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyDBSubnetGroup", input)
	return &ModifyDBSubnetGroupFuture{Future: future}
}

func (a *stub) ModifyEventSubscription(ctx workflow.Context, input *rds.ModifyEventSubscriptionInput) (*rds.ModifyEventSubscriptionOutput, error) {
	var output rds.ModifyEventSubscriptionOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyEventSubscription", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyEventSubscriptionAsync(ctx workflow.Context, input *rds.ModifyEventSubscriptionInput) *ModifyEventSubscriptionFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyEventSubscription", input)
	return &ModifyEventSubscriptionFuture{Future: future}
}

func (a *stub) ModifyGlobalCluster(ctx workflow.Context, input *rds.ModifyGlobalClusterInput) (*rds.ModifyGlobalClusterOutput, error) {
	var output rds.ModifyGlobalClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyGlobalCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyGlobalClusterAsync(ctx workflow.Context, input *rds.ModifyGlobalClusterInput) *ModifyGlobalClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyGlobalCluster", input)
	return &ModifyGlobalClusterFuture{Future: future}
}

func (a *stub) ModifyOptionGroup(ctx workflow.Context, input *rds.ModifyOptionGroupInput) (*rds.ModifyOptionGroupOutput, error) {
	var output rds.ModifyOptionGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-ModifyOptionGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ModifyOptionGroupAsync(ctx workflow.Context, input *rds.ModifyOptionGroupInput) *ModifyOptionGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ModifyOptionGroup", input)
	return &ModifyOptionGroupFuture{Future: future}
}

func (a *stub) PromoteReadReplica(ctx workflow.Context, input *rds.PromoteReadReplicaInput) (*rds.PromoteReadReplicaOutput, error) {
	var output rds.PromoteReadReplicaOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-PromoteReadReplica", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) PromoteReadReplicaAsync(ctx workflow.Context, input *rds.PromoteReadReplicaInput) *PromoteReadReplicaFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-PromoteReadReplica", input)
	return &PromoteReadReplicaFuture{Future: future}
}

func (a *stub) PromoteReadReplicaDBCluster(ctx workflow.Context, input *rds.PromoteReadReplicaDBClusterInput) (*rds.PromoteReadReplicaDBClusterOutput, error) {
	var output rds.PromoteReadReplicaDBClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-PromoteReadReplicaDBCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) PromoteReadReplicaDBClusterAsync(ctx workflow.Context, input *rds.PromoteReadReplicaDBClusterInput) *PromoteReadReplicaDBClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-PromoteReadReplicaDBCluster", input)
	return &PromoteReadReplicaDBClusterFuture{Future: future}
}

func (a *stub) PurchaseReservedDBInstancesOffering(ctx workflow.Context, input *rds.PurchaseReservedDBInstancesOfferingInput) (*rds.PurchaseReservedDBInstancesOfferingOutput, error) {
	var output rds.PurchaseReservedDBInstancesOfferingOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-PurchaseReservedDBInstancesOffering", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) PurchaseReservedDBInstancesOfferingAsync(ctx workflow.Context, input *rds.PurchaseReservedDBInstancesOfferingInput) *PurchaseReservedDBInstancesOfferingFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-PurchaseReservedDBInstancesOffering", input)
	return &PurchaseReservedDBInstancesOfferingFuture{Future: future}
}

func (a *stub) RebootDBInstance(ctx workflow.Context, input *rds.RebootDBInstanceInput) (*rds.RebootDBInstanceOutput, error) {
	var output rds.RebootDBInstanceOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-RebootDBInstance", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RebootDBInstanceAsync(ctx workflow.Context, input *rds.RebootDBInstanceInput) *RebootDBInstanceFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RebootDBInstance", input)
	return &RebootDBInstanceFuture{Future: future}
}

func (a *stub) RegisterDBProxyTargets(ctx workflow.Context, input *rds.RegisterDBProxyTargetsInput) (*rds.RegisterDBProxyTargetsOutput, error) {
	var output rds.RegisterDBProxyTargetsOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-RegisterDBProxyTargets", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RegisterDBProxyTargetsAsync(ctx workflow.Context, input *rds.RegisterDBProxyTargetsInput) *RegisterDBProxyTargetsFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RegisterDBProxyTargets", input)
	return &RegisterDBProxyTargetsFuture{Future: future}
}

func (a *stub) RemoveFromGlobalCluster(ctx workflow.Context, input *rds.RemoveFromGlobalClusterInput) (*rds.RemoveFromGlobalClusterOutput, error) {
	var output rds.RemoveFromGlobalClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-RemoveFromGlobalCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RemoveFromGlobalClusterAsync(ctx workflow.Context, input *rds.RemoveFromGlobalClusterInput) *RemoveFromGlobalClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RemoveFromGlobalCluster", input)
	return &RemoveFromGlobalClusterFuture{Future: future}
}

func (a *stub) RemoveRoleFromDBCluster(ctx workflow.Context, input *rds.RemoveRoleFromDBClusterInput) (*rds.RemoveRoleFromDBClusterOutput, error) {
	var output rds.RemoveRoleFromDBClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-RemoveRoleFromDBCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RemoveRoleFromDBClusterAsync(ctx workflow.Context, input *rds.RemoveRoleFromDBClusterInput) *RemoveRoleFromDBClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RemoveRoleFromDBCluster", input)
	return &RemoveRoleFromDBClusterFuture{Future: future}
}

func (a *stub) RemoveRoleFromDBInstance(ctx workflow.Context, input *rds.RemoveRoleFromDBInstanceInput) (*rds.RemoveRoleFromDBInstanceOutput, error) {
	var output rds.RemoveRoleFromDBInstanceOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-RemoveRoleFromDBInstance", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RemoveRoleFromDBInstanceAsync(ctx workflow.Context, input *rds.RemoveRoleFromDBInstanceInput) *RemoveRoleFromDBInstanceFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RemoveRoleFromDBInstance", input)
	return &RemoveRoleFromDBInstanceFuture{Future: future}
}

func (a *stub) RemoveSourceIdentifierFromSubscription(ctx workflow.Context, input *rds.RemoveSourceIdentifierFromSubscriptionInput) (*rds.RemoveSourceIdentifierFromSubscriptionOutput, error) {
	var output rds.RemoveSourceIdentifierFromSubscriptionOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-RemoveSourceIdentifierFromSubscription", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RemoveSourceIdentifierFromSubscriptionAsync(ctx workflow.Context, input *rds.RemoveSourceIdentifierFromSubscriptionInput) *RemoveSourceIdentifierFromSubscriptionFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RemoveSourceIdentifierFromSubscription", input)
	return &RemoveSourceIdentifierFromSubscriptionFuture{Future: future}
}

func (a *stub) RemoveTagsFromResource(ctx workflow.Context, input *rds.RemoveTagsFromResourceInput) (*rds.RemoveTagsFromResourceOutput, error) {
	var output rds.RemoveTagsFromResourceOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-RemoveTagsFromResource", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RemoveTagsFromResourceAsync(ctx workflow.Context, input *rds.RemoveTagsFromResourceInput) *RemoveTagsFromResourceFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RemoveTagsFromResource", input)
	return &RemoveTagsFromResourceFuture{Future: future}
}

func (a *stub) ResetDBClusterParameterGroup(ctx workflow.Context, input *rds.ResetDBClusterParameterGroupInput) (*rds.DBClusterParameterGroupNameMessage, error) {
	var output rds.DBClusterParameterGroupNameMessage
	err := workflow.ExecuteActivity(ctx, "aws-rds-ResetDBClusterParameterGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ResetDBClusterParameterGroupAsync(ctx workflow.Context, input *rds.ResetDBClusterParameterGroupInput) *ResetDBClusterParameterGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ResetDBClusterParameterGroup", input)
	return &ResetDBClusterParameterGroupFuture{Future: future}
}

func (a *stub) ResetDBParameterGroup(ctx workflow.Context, input *rds.ResetDBParameterGroupInput) (*rds.DBParameterGroupNameMessage, error) {
	var output rds.DBParameterGroupNameMessage
	err := workflow.ExecuteActivity(ctx, "aws-rds-ResetDBParameterGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ResetDBParameterGroupAsync(ctx workflow.Context, input *rds.ResetDBParameterGroupInput) *ResetDBParameterGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-ResetDBParameterGroup", input)
	return &ResetDBParameterGroupFuture{Future: future}
}

func (a *stub) RestoreDBClusterFromS3(ctx workflow.Context, input *rds.RestoreDBClusterFromS3Input) (*rds.RestoreDBClusterFromS3Output, error) {
	var output rds.RestoreDBClusterFromS3Output
	err := workflow.ExecuteActivity(ctx, "aws-rds-RestoreDBClusterFromS3", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RestoreDBClusterFromS3Async(ctx workflow.Context, input *rds.RestoreDBClusterFromS3Input) *RestoreDBClusterFromS3Future {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RestoreDBClusterFromS3", input)
	return &RestoreDBClusterFromS3Future{Future: future}
}

func (a *stub) RestoreDBClusterFromSnapshot(ctx workflow.Context, input *rds.RestoreDBClusterFromSnapshotInput) (*rds.RestoreDBClusterFromSnapshotOutput, error) {
	var output rds.RestoreDBClusterFromSnapshotOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-RestoreDBClusterFromSnapshot", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RestoreDBClusterFromSnapshotAsync(ctx workflow.Context, input *rds.RestoreDBClusterFromSnapshotInput) *RestoreDBClusterFromSnapshotFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RestoreDBClusterFromSnapshot", input)
	return &RestoreDBClusterFromSnapshotFuture{Future: future}
}

func (a *stub) RestoreDBClusterToPointInTime(ctx workflow.Context, input *rds.RestoreDBClusterToPointInTimeInput) (*rds.RestoreDBClusterToPointInTimeOutput, error) {
	var output rds.RestoreDBClusterToPointInTimeOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-RestoreDBClusterToPointInTime", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RestoreDBClusterToPointInTimeAsync(ctx workflow.Context, input *rds.RestoreDBClusterToPointInTimeInput) *RestoreDBClusterToPointInTimeFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RestoreDBClusterToPointInTime", input)
	return &RestoreDBClusterToPointInTimeFuture{Future: future}
}

func (a *stub) RestoreDBInstanceFromDBSnapshot(ctx workflow.Context, input *rds.RestoreDBInstanceFromDBSnapshotInput) (*rds.RestoreDBInstanceFromDBSnapshotOutput, error) {
	var output rds.RestoreDBInstanceFromDBSnapshotOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-RestoreDBInstanceFromDBSnapshot", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RestoreDBInstanceFromDBSnapshotAsync(ctx workflow.Context, input *rds.RestoreDBInstanceFromDBSnapshotInput) *RestoreDBInstanceFromDBSnapshotFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RestoreDBInstanceFromDBSnapshot", input)
	return &RestoreDBInstanceFromDBSnapshotFuture{Future: future}
}

func (a *stub) RestoreDBInstanceFromS3(ctx workflow.Context, input *rds.RestoreDBInstanceFromS3Input) (*rds.RestoreDBInstanceFromS3Output, error) {
	var output rds.RestoreDBInstanceFromS3Output
	err := workflow.ExecuteActivity(ctx, "aws-rds-RestoreDBInstanceFromS3", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RestoreDBInstanceFromS3Async(ctx workflow.Context, input *rds.RestoreDBInstanceFromS3Input) *RestoreDBInstanceFromS3Future {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RestoreDBInstanceFromS3", input)
	return &RestoreDBInstanceFromS3Future{Future: future}
}

func (a *stub) RestoreDBInstanceToPointInTime(ctx workflow.Context, input *rds.RestoreDBInstanceToPointInTimeInput) (*rds.RestoreDBInstanceToPointInTimeOutput, error) {
	var output rds.RestoreDBInstanceToPointInTimeOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-RestoreDBInstanceToPointInTime", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RestoreDBInstanceToPointInTimeAsync(ctx workflow.Context, input *rds.RestoreDBInstanceToPointInTimeInput) *RestoreDBInstanceToPointInTimeFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RestoreDBInstanceToPointInTime", input)
	return &RestoreDBInstanceToPointInTimeFuture{Future: future}
}

func (a *stub) RevokeDBSecurityGroupIngress(ctx workflow.Context, input *rds.RevokeDBSecurityGroupIngressInput) (*rds.RevokeDBSecurityGroupIngressOutput, error) {
	var output rds.RevokeDBSecurityGroupIngressOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-RevokeDBSecurityGroupIngress", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RevokeDBSecurityGroupIngressAsync(ctx workflow.Context, input *rds.RevokeDBSecurityGroupIngressInput) *RevokeDBSecurityGroupIngressFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-RevokeDBSecurityGroupIngress", input)
	return &RevokeDBSecurityGroupIngressFuture{Future: future}
}

func (a *stub) StartActivityStream(ctx workflow.Context, input *rds.StartActivityStreamInput) (*rds.StartActivityStreamOutput, error) {
	var output rds.StartActivityStreamOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-StartActivityStream", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) StartActivityStreamAsync(ctx workflow.Context, input *rds.StartActivityStreamInput) *StartActivityStreamFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-StartActivityStream", input)
	return &StartActivityStreamFuture{Future: future}
}

func (a *stub) StartDBCluster(ctx workflow.Context, input *rds.StartDBClusterInput) (*rds.StartDBClusterOutput, error) {
	var output rds.StartDBClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-StartDBCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) StartDBClusterAsync(ctx workflow.Context, input *rds.StartDBClusterInput) *StartDBClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-StartDBCluster", input)
	return &StartDBClusterFuture{Future: future}
}

func (a *stub) StartDBInstance(ctx workflow.Context, input *rds.StartDBInstanceInput) (*rds.StartDBInstanceOutput, error) {
	var output rds.StartDBInstanceOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-StartDBInstance", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) StartDBInstanceAsync(ctx workflow.Context, input *rds.StartDBInstanceInput) *StartDBInstanceFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-StartDBInstance", input)
	return &StartDBInstanceFuture{Future: future}
}

func (a *stub) StartDBInstanceAutomatedBackupsReplication(ctx workflow.Context, input *rds.StartDBInstanceAutomatedBackupsReplicationInput) (*rds.StartDBInstanceAutomatedBackupsReplicationOutput, error) {
	var output rds.StartDBInstanceAutomatedBackupsReplicationOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-StartDBInstanceAutomatedBackupsReplication", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) StartDBInstanceAutomatedBackupsReplicationAsync(ctx workflow.Context, input *rds.StartDBInstanceAutomatedBackupsReplicationInput) *StartDBInstanceAutomatedBackupsReplicationFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-StartDBInstanceAutomatedBackupsReplication", input)
	return &StartDBInstanceAutomatedBackupsReplicationFuture{Future: future}
}

func (a *stub) StartExportTask(ctx workflow.Context, input *rds.StartExportTaskInput) (*rds.StartExportTaskOutput, error) {
	var output rds.StartExportTaskOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-StartExportTask", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) StartExportTaskAsync(ctx workflow.Context, input *rds.StartExportTaskInput) *StartExportTaskFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-StartExportTask", input)
	return &StartExportTaskFuture{Future: future}
}

func (a *stub) StopActivityStream(ctx workflow.Context, input *rds.StopActivityStreamInput) (*rds.StopActivityStreamOutput, error) {
	var output rds.StopActivityStreamOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-StopActivityStream", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) StopActivityStreamAsync(ctx workflow.Context, input *rds.StopActivityStreamInput) *StopActivityStreamFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-StopActivityStream", input)
	return &StopActivityStreamFuture{Future: future}
}

func (a *stub) StopDBCluster(ctx workflow.Context, input *rds.StopDBClusterInput) (*rds.StopDBClusterOutput, error) {
	var output rds.StopDBClusterOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-StopDBCluster", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) StopDBClusterAsync(ctx workflow.Context, input *rds.StopDBClusterInput) *StopDBClusterFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-StopDBCluster", input)
	return &StopDBClusterFuture{Future: future}
}

func (a *stub) StopDBInstance(ctx workflow.Context, input *rds.StopDBInstanceInput) (*rds.StopDBInstanceOutput, error) {
	var output rds.StopDBInstanceOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-StopDBInstance", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) StopDBInstanceAsync(ctx workflow.Context, input *rds.StopDBInstanceInput) *StopDBInstanceFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-StopDBInstance", input)
	return &StopDBInstanceFuture{Future: future}
}

func (a *stub) StopDBInstanceAutomatedBackupsReplication(ctx workflow.Context, input *rds.StopDBInstanceAutomatedBackupsReplicationInput) (*rds.StopDBInstanceAutomatedBackupsReplicationOutput, error) {
	var output rds.StopDBInstanceAutomatedBackupsReplicationOutput
	err := workflow.ExecuteActivity(ctx, "aws-rds-StopDBInstanceAutomatedBackupsReplication", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) StopDBInstanceAutomatedBackupsReplicationAsync(ctx workflow.Context, input *rds.StopDBInstanceAutomatedBackupsReplicationInput) *StopDBInstanceAutomatedBackupsReplicationFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-StopDBInstanceAutomatedBackupsReplication", input)
	return &StopDBInstanceAutomatedBackupsReplicationFuture{Future: future}
}

func (a *stub) WaitUntilDBClusterSnapshotAvailable(ctx workflow.Context, input *rds.DescribeDBClusterSnapshotsInput) error {
	return workflow.ExecuteActivity(ctx, "aws-rds-WaitUntilDBClusterSnapshotAvailable", input).Get(ctx, nil)
}

func (a *stub) WaitUntilDBClusterSnapshotAvailableAsync(ctx workflow.Context, input *rds.DescribeDBClusterSnapshotsInput) *clients.VoidFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-WaitUntilDBClusterSnapshotAvailable", input)
	return clients.NewVoidFuture(future)
}

func (a *stub) WaitUntilDBClusterSnapshotDeleted(ctx workflow.Context, input *rds.DescribeDBClusterSnapshotsInput) error {
	return workflow.ExecuteActivity(ctx, "aws-rds-WaitUntilDBClusterSnapshotDeleted", input).Get(ctx, nil)
}

func (a *stub) WaitUntilDBClusterSnapshotDeletedAsync(ctx workflow.Context, input *rds.DescribeDBClusterSnapshotsInput) *clients.VoidFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-WaitUntilDBClusterSnapshotDeleted", input)
	return clients.NewVoidFuture(future)
}

func (a *stub) WaitUntilDBInstanceAvailable(ctx workflow.Context, input *rds.DescribeDBInstancesInput) error {
	return workflow.ExecuteActivity(ctx, "aws-rds-WaitUntilDBInstanceAvailable", input).Get(ctx, nil)
}

func (a *stub) WaitUntilDBInstanceAvailableAsync(ctx workflow.Context, input *rds.DescribeDBInstancesInput) *clients.VoidFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-WaitUntilDBInstanceAvailable", input)
	return clients.NewVoidFuture(future)
}

func (a *stub) WaitUntilDBInstanceDeleted(ctx workflow.Context, input *rds.DescribeDBInstancesInput) error {
	return workflow.ExecuteActivity(ctx, "aws-rds-WaitUntilDBInstanceDeleted", input).Get(ctx, nil)
}

func (a *stub) WaitUntilDBInstanceDeletedAsync(ctx workflow.Context, input *rds.DescribeDBInstancesInput) *clients.VoidFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-WaitUntilDBInstanceDeleted", input)
	return clients.NewVoidFuture(future)
}

func (a *stub) WaitUntilDBSnapshotAvailable(ctx workflow.Context, input *rds.DescribeDBSnapshotsInput) error {
	return workflow.ExecuteActivity(ctx, "aws-rds-WaitUntilDBSnapshotAvailable", input).Get(ctx, nil)
}

func (a *stub) WaitUntilDBSnapshotAvailableAsync(ctx workflow.Context, input *rds.DescribeDBSnapshotsInput) *clients.VoidFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-WaitUntilDBSnapshotAvailable", input)
	return clients.NewVoidFuture(future)
}

func (a *stub) WaitUntilDBSnapshotDeleted(ctx workflow.Context, input *rds.DescribeDBSnapshotsInput) error {
	return workflow.ExecuteActivity(ctx, "aws-rds-WaitUntilDBSnapshotDeleted", input).Get(ctx, nil)
}

func (a *stub) WaitUntilDBSnapshotDeletedAsync(ctx workflow.Context, input *rds.DescribeDBSnapshotsInput) *clients.VoidFuture {
	future := workflow.ExecuteActivity(ctx, "aws-rds-WaitUntilDBSnapshotDeleted", input)
	return clients.NewVoidFuture(future)
}