export interface DBInstance {
    DBInstanceIdentifier?: string;
    DBInstanceClass?: string;
    Engine?: string;
    EngineVersion?: string;
    DBInstanceStatus?: string;
    MasterUsername?: string;
    DBName?: string;
    Endpoint?: {
        Address?: string;
        Port?: number;
        HostedZoneId?: string;
    };
    AllocatedStorage?: number;
    InstanceCreateTime?: string;
    PreferredBackupWindow?: string;
    BackupRetentionPeriod?: number;
    DBSecurityGroups?: Array<{
        DBSecurityGroupName?: string;
        Status?: string;
    }>;
    VpcSecurityGroups?: Array<{
        VpcSecurityGroupId?: string;
        Status?: string;
    }>;
    DBParameterGroups?: Array<{
        DBParameterGroupName?: string;
        ParameterApplyStatus?: string;
    }>;
    AvailabilityZone?: string;
    DBSubnetGroup?: {
        DBSubnetGroupName?: string;
        DBSubnetGroupDescription?: string;
        VpcId?: string;
        SubnetGroupStatus?: string;
        Subnets?: Array<{
            SubnetIdentifier?: string;
            SubnetAvailabilityZone?: {
                Name?: string;
            };
            SubnetStatus?: string;
        }>;
    };
    PreferredMaintenanceWindow?: string;
    PendingModifiedValues?: Record<string, any>;
    MultiAZ?: boolean;
    AutoMinorVersionUpgrade?: boolean;
    ReadReplicaSourceDBInstanceIdentifier?: string;
    ReadReplicaDBInstanceIdentifiers?: string[];
    LicenseModel?: string;
    OptionGroupMemberships?: Array<{
        OptionGroupName?: string;
        Status?: string;
    }>;
    PubliclyAccessible?: boolean;
    StorageType?: string;
    StorageEncrypted?: boolean;
    KmsKeyId?: string;
    DbiResourceId?: string;
    CACertificateIdentifier?: string;
    DeletionProtection?: boolean;
    TagList?: Array<{
        Key?: string;
        Value?: string;
    }>;
}
export interface DBCluster {
    DBClusterIdentifier?: string;
    DBClusterArn?: string;
    Status?: string;
    Engine?: string;
    EngineVersion?: string;
    Endpoint?: string;
    ReaderEndpoint?: string;
    Port?: number;
    MasterUsername?: string;
    DatabaseName?: string;
    PreferredBackupWindow?: string;
    PreferredMaintenanceWindow?: string;
    MultiAZ?: boolean;
    EngineMode?: string;
    DBClusterMembers?: Array<{
        DBInstanceIdentifier?: string;
        IsClusterWriter?: boolean;
        DBClusterParameterGroupStatus?: string;
    }>;
    VpcSecurityGroups?: Array<{
        VpcSecurityGroupId?: string;
        Status?: string;
    }>;
    HostedZoneId?: string;
    StorageEncrypted?: boolean;
    KmsKeyId?: string;
    DeletionProtection?: boolean;
    TagList?: Array<{
        Key?: string;
        Value?: string;
    }>;
}
export interface DBSnapshot {
    DBSnapshotIdentifier?: string;
    DBInstanceIdentifier?: string;
    SnapshotCreateTime?: string;
    Engine?: string;
    AllocatedStorage?: number;
    Status?: string;
    Port?: number;
    AvailabilityZone?: string;
    VpcId?: string;
    InstanceCreateTime?: string;
    MasterUsername?: string;
    EngineVersion?: string;
    LicenseModel?: string;
    SnapshotType?: string;
    OptionGroupName?: string;
    PercentProgress?: number;
    SourceRegion?: string;
    StorageType?: string;
    Encrypted?: boolean;
    KmsKeyId?: string;
    DBSnapshotArn?: string;
}
export interface DBSubnetGroup {
    DBSubnetGroupName?: string;
    DBSubnetGroupDescription?: string;
    VpcId?: string;
    SubnetGroupStatus?: string;
    Subnets?: Array<{
        SubnetIdentifier?: string;
        SubnetAvailabilityZone?: {
            Name?: string;
        };
        SubnetStatus?: string;
    }>;
    DBSubnetGroupArn?: string;
}
/**
 * RDS service management using direct API calls
 */
export declare class RDSClient {
    private client;
    private region;
    constructor(region?: string);
    /**
     * Describe all RDS DB instances
     */
    describeDBInstances(options?: {
        DBInstanceIdentifier?: string;
        Filters?: Array<{
            Name: string;
            Values: string[];
        }>;
        MaxRecords?: number;
        Marker?: string;
    }): Promise<{
        DBInstances?: DBInstance[];
        Marker?: string;
    }>;
    /**
     * Describe a specific DB instance
     */
    describeDBInstance(dbInstanceIdentifier: string): Promise<DBInstance | undefined>;
    /**
     * Describe all RDS DB clusters (Aurora)
     */
    describeDBClusters(options?: {
        DBClusterIdentifier?: string;
        Filters?: Array<{
            Name: string;
            Values: string[];
        }>;
        MaxRecords?: number;
        Marker?: string;
    }): Promise<{
        DBClusters?: DBCluster[];
        Marker?: string;
    }>;
    /**
     * Describe DB snapshots
     */
    describeDBSnapshots(options?: {
        DBInstanceIdentifier?: string;
        DBSnapshotIdentifier?: string;
        SnapshotType?: 'automated' | 'manual' | 'shared' | 'public' | 'awsbackup';
        MaxRecords?: number;
        Marker?: string;
    }): Promise<{
        DBSnapshots?: DBSnapshot[];
        Marker?: string;
    }>;
    /**
     * Describe DB subnet groups
     */
    describeDBSubnetGroups(options?: {
        DBSubnetGroupName?: string;
        MaxRecords?: number;
        Marker?: string;
    }): Promise<{
        DBSubnetGroups?: DBSubnetGroup[];
        Marker?: string;
    }>;
    /**
     * Create a new DB instance
     */
    createDBInstance(options: {
        DBInstanceIdentifier: string;
        DBInstanceClass: string;
        Engine: string;
        /** Attach this instance to an existing cluster (Aurora writer/reader). */
        DBClusterIdentifier?: string;
        MasterUsername?: string;
        MasterUserPassword?: string;
        DBName?: string;
        AllocatedStorage?: number;
        VpcSecurityGroupIds?: string[];
        DBSubnetGroupName?: string;
        AvailabilityZone?: string;
        PreferredMaintenanceWindow?: string;
        PreferredBackupWindow?: string;
        BackupRetentionPeriod?: number;
        MultiAZ?: boolean;
        EngineVersion?: string;
        AutoMinorVersionUpgrade?: boolean;
        LicenseModel?: string;
        PubliclyAccessible?: boolean;
        StorageType?: 'gp2' | 'gp3' | 'io1' | 'standard';
        StorageEncrypted?: boolean;
        KmsKeyId?: string;
        DeletionProtection?: boolean;
        Tags?: Array<{
            Key: string;
            Value: string;
        }>;
    }): Promise<{
        DBInstance?: DBInstance;
    }>;
    /** Create an Aurora-compatible DB cluster. */
    createDBCluster(options: {
        DBClusterIdentifier: string;
        Engine: string;
        EngineVersion?: string;
        MasterUsername?: string;
        MasterUserPassword?: string;
        DatabaseName?: string;
        DBSubnetGroupName?: string;
        VpcSecurityGroupIds?: string[];
        BackupRetentionPeriod?: number;
        StorageEncrypted?: boolean;
        KmsKeyId?: string;
        DeletionProtection?: boolean;
        ServerlessV2ScalingConfiguration?: {
            MinCapacity: number;
            MaxCapacity: number;
        };
    }): Promise<{
        DBCluster?: DBCluster;
    }>;
    /**
     * Delete a DB instance
     */
    deleteDBInstance(options: {
        DBInstanceIdentifier: string;
        SkipFinalSnapshot?: boolean;
        FinalDBSnapshotIdentifier?: string;
        DeleteAutomatedBackups?: boolean;
    }): Promise<{
        DBInstance?: DBInstance;
    }>;
    /**
     * Modify a DB instance
     */
    modifyDBInstance(options: {
        DBInstanceIdentifier: string;
        DBInstanceClass?: string;
        AllocatedStorage?: number;
        MasterUserPassword?: string;
        BackupRetentionPeriod?: number;
        PreferredBackupWindow?: string;
        PreferredMaintenanceWindow?: string;
        MultiAZ?: boolean;
        EngineVersion?: string;
        AutoMinorVersionUpgrade?: boolean;
        PubliclyAccessible?: boolean;
        VpcSecurityGroupIds?: string[];
        ApplyImmediately?: boolean;
        StorageType?: 'gp2' | 'gp3' | 'io1' | 'standard';
        DeletionProtection?: boolean;
    }): Promise<{
        DBInstance?: DBInstance;
    }>;
    /**
     * Modify a DB cluster — used to rescale an Aurora Serverless v2 cluster's
     * ServerlessV2 min/max ACU capacity.
     */
    modifyDBCluster(options: {
        DBClusterIdentifier: string;
        ServerlessV2ScalingConfiguration?: {
            MinCapacity: number;
            MaxCapacity: number;
        };
        BackupRetentionPeriod?: number;
        EngineVersion?: string;
        MasterUserPassword?: string;
        DeletionProtection?: boolean;
        ApplyImmediately?: boolean;
    }): Promise<{
        DBCluster?: DBCluster;
    }>;
    /** Reboot/fail over an Aurora cluster. */
    rebootDBCluster(dbClusterIdentifier: string): Promise<{
        DBCluster?: DBCluster;
    }>;
    /** Create a manual Aurora cluster snapshot. */
    createDBClusterSnapshot(dbClusterIdentifier: string, snapshotIdentifier: string): Promise<Record<string, any>>;
    /** Describe Aurora cluster snapshots, optionally by exact identifier. */
    describeDBClusterSnapshots(options?: {
        DBClusterIdentifier?: string;
        DBClusterSnapshotIdentifier?: string;
    }): Promise<{
        DBClusterSnapshots: Array<Record<string, any>>;
    }>;
    /** Delete one Aurora cluster snapshot managed by ts-cloud. */
    deleteDBClusterSnapshot(snapshotIdentifier: string): Promise<void>;
    /** Delete an Aurora cluster with a final snapshot by default. */
    deleteDBCluster(dbClusterIdentifier: string, finalSnapshotIdentifier?: string): Promise<{
        DBCluster?: DBCluster;
    }>;
    /**
     * Restore an Aurora cluster to a point in time as a NEW cluster (the source is
     * left untouched). Either RestoreToTime or UseLatestRestorableTime is required.
     */
    restoreDBClusterToPointInTime(options: {
        DBClusterIdentifier: string;
        SourceDBClusterIdentifier: string;
        RestoreToTime?: Date;
        UseLatestRestorableTime?: boolean;
        VpcSecurityGroupIds?: string[];
        DBSubnetGroupName?: string;
    }): Promise<{
        DBCluster?: DBCluster;
    }>;
    /** Restore an Aurora snapshot into a new deletion-protected cluster. */
    restoreDBClusterFromSnapshot(options: {
        DBClusterIdentifier: string;
        SnapshotIdentifier: string;
        Engine: 'aurora-mysql' | 'aurora-postgresql';
        EngineVersion?: string;
        DBSubnetGroupName?: string;
        VpcSecurityGroupIds?: string[];
        DeletionProtection?: boolean;
        ServerlessV2ScalingConfiguration?: {
            MinCapacity: number;
            MaxCapacity: number;
        };
    }): Promise<{
        DBCluster?: DBCluster;
    }>;
    /**
     * Start a DB instance
     */
    startDBInstance(dbInstanceIdentifier: string): Promise<{
        DBInstance?: DBInstance;
    }>;
    /**
     * Stop a DB instance
     */
    stopDBInstance(options: {
        DBInstanceIdentifier: string;
        DBSnapshotIdentifier?: string;
    }): Promise<{
        DBInstance?: DBInstance;
    }>;
    /**
     * Reboot a DB instance
     */
    rebootDBInstance(options: {
        DBInstanceIdentifier: string;
        ForceFailover?: boolean;
    }): Promise<{
        DBInstance?: DBInstance;
    }>;
    /**
     * Create a DB snapshot
     */
    createDBSnapshot(options: {
        DBInstanceIdentifier: string;
        DBSnapshotIdentifier: string;
        Tags?: Array<{
            Key: string;
            Value: string;
        }>;
    }): Promise<{
        DBSnapshot?: DBSnapshot;
    }>;
    /**
     * Delete a DB snapshot
     */
    deleteDBSnapshot(dbSnapshotIdentifier: string): Promise<{
        DBSnapshot?: DBSnapshot;
    }>;
    /**
     * Restore DB instance from snapshot
     */
    restoreDBInstanceFromDBSnapshot(options: {
        DBInstanceIdentifier: string;
        DBSnapshotIdentifier: string;
        DBInstanceClass?: string;
        Port?: number;
        AvailabilityZone?: string;
        DBSubnetGroupName?: string;
        MultiAZ?: boolean;
        PubliclyAccessible?: boolean;
        AutoMinorVersionUpgrade?: boolean;
        StorageType?: 'gp2' | 'gp3' | 'io1' | 'standard';
        VpcSecurityGroupIds?: string[];
        DeletionProtection?: boolean;
        Tags?: Array<{
            Key: string;
            Value: string;
        }>;
    }): Promise<{
        DBInstance?: DBInstance;
    }>;
    /**
     * Wait for DB instance to become available
     */
    waitForDBInstanceAvailable(dbInstanceIdentifier: string, maxAttempts?: number, delayMs?: number): Promise<DBInstance | undefined>;
    /**
     * Wait for DB instance to be deleted
     */
    waitForDBInstanceDeleted(dbInstanceIdentifier: string, maxAttempts?: number, delayMs?: number): Promise<void>;
}
