export interface CertificateDetail {
    CertificateArn: string;
    DomainName: string;
    SubjectAlternativeNames?: string[];
    Status: 'PENDING_VALIDATION' | 'ISSUED' | 'INACTIVE' | 'EXPIRED' | 'VALIDATION_TIMED_OUT' | 'REVOKED' | 'FAILED';
    Type?: 'IMPORTED' | 'AMAZON_ISSUED' | 'PRIVATE';
    DomainValidationOptions?: {
        DomainName: string;
        ValidationDomain?: string;
        ValidationStatus?: 'PENDING_VALIDATION' | 'SUCCESS' | 'FAILED';
        ResourceRecord?: {
            Name: string;
            Type: string;
            Value: string;
        };
        ValidationMethod?: 'EMAIL' | 'DNS';
    }[];
    CreatedAt?: string;
    IssuedAt?: string;
    NotBefore?: string;
    NotAfter?: string;
}
export declare class ACMClient {
    private client;
    private region;
    constructor(region?: string);
    /**
     * Request a new certificate
     */
    requestCertificate(params: {
        DomainName: string;
        SubjectAlternativeNames?: string[];
        ValidationMethod?: 'EMAIL' | 'DNS';
    }): Promise<{
        CertificateArn: string;
    }>;
    /**
     * Describe a certificate to get its details and validation options
     */
    describeCertificate(params: {
        CertificateArn: string;
    }): Promise<CertificateDetail>;
    /**
     * List certificates
     */
    listCertificates(params?: {
        CertificateStatuses?: ('PENDING_VALIDATION' | 'ISSUED' | 'INACTIVE' | 'EXPIRED' | 'VALIDATION_TIMED_OUT' | 'REVOKED' | 'FAILED')[];
        MaxItems?: number;
        NextToken?: string;
    }): Promise<{
        CertificateSummaryList: {
            CertificateArn: string;
            DomainName: string;
        }[];
        NextToken?: string;
    }>;
    /**
     * Delete a certificate
     */
    deleteCertificate(params: {
        CertificateArn: string;
    }): Promise<void>;
    /**
     * Get certificate tags
     */
    listTagsForCertificate(params: {
        CertificateArn: string;
    }): Promise<{
        Tags: Array<{
            Key: string;
            Value?: string;
        }>;
    }>;
    /**
     * Add tags to a certificate
     */
    addTagsToCertificate(params: {
        CertificateArn: string;
        Tags: Array<{
            Key: string;
            Value?: string;
        }>;
    }): Promise<void>;
    /**
     * Resend validation email
     */
    resendValidationEmail(params: {
        CertificateArn: string;
        Domain: string;
        ValidationDomain: string;
    }): Promise<void>;
    /**
     * Find certificate by domain name
     */
    findCertificateByDomain(domainName: string): Promise<CertificateDetail | null>;
    /**
     * Wait for certificate to be issued
     */
    waitForCertificateValidation(certificateArn: string, maxAttempts?: number, delayMs?: number): Promise<CertificateDetail | null>;
    /**
     * Get DNS validation records for a certificate
     */
    getDnsValidationRecords(certificateArn: string): Promise<Array<{
        domainName: string;
        recordName: string;
        recordType: string;
        recordValue: string;
    }>>;
    /**
     * Request certificate for a domain with common SANs
     * Automatically includes www and wildcard
     */
    requestCertificateWithSans(params: {
        DomainName: string;
        IncludeWww?: boolean;
        IncludeWildcard?: boolean;
        AdditionalSans?: string[];
    }): Promise<{
        CertificateArn: string;
    }>;
    /**
     * Check if certificate is valid for a given domain
     */
    isCertificateValidForDomain(certificateArn: string, domainName: string): Promise<boolean>;
}
import type { DnsProviderConfig } from '../dns/types';
/**
 * Helper class for ACM DNS validation with Route53 integration
 * @deprecated Use UnifiedDnsValidator from 'ts-cloud/dns' for multi-provider support (Route53, Porkbun, GoDaddy)
 */
export declare class ACMDnsValidator {
    private acm;
    private route53;
    private dnsProvider?;
    /**
     * Create ACM DNS validator
     * @param region - AWS region for ACM (default: us-east-1)
     * @param dnsProviderConfig - Optional external DNS provider config (Porkbun, GoDaddy)
     */
    constructor(region?: string, dnsProviderConfig?: DnsProviderConfig);
    /**
     * Request certificate and automatically create DNS validation records
     * @param params.domainName - Primary domain name for the certificate
     * @param params.hostedZoneId - Route53 hosted zone ID (required if no external DNS provider configured)
     * @param params.subjectAlternativeNames - Additional domain names (SANs)
     * @param params.waitForValidation - Wait for certificate to be issued
     * @param params.maxWaitMinutes - Maximum wait time in minutes
     */
    requestAndValidate(params: {
        domainName: string;
        hostedZoneId?: string;
        subjectAlternativeNames?: string[];
        waitForValidation?: boolean;
        maxWaitMinutes?: number;
    }): Promise<{
        certificateArn: string;
        validationRecords: Array<{
            domainName: string;
            recordName: string;
            recordValue: string;
        }>;
    }>;
    /**
     * Wait for validation options to become available
     */
    private waitForValidationOptions;
    /**
     * Create validation records for an existing certificate
     * Uses external DNS provider if configured, otherwise Route53
     */
    createValidationRecords(params: {
        certificateArn: string;
        hostedZoneId?: string;
        domain?: string;
    }): Promise<Array<{
        domainName: string;
        recordName: string;
        recordValue: string;
        changeId?: string;
    }>>;
    /**
     * Delete validation records after certificate is issued
     * Uses external DNS provider if configured, otherwise Route53
     */
    deleteValidationRecords(params: {
        certificateArn: string;
        hostedZoneId?: string;
        domain?: string;
    }): Promise<void>;
    /**
     * Find or create a certificate for a domain
     * Uses external DNS provider if configured, otherwise Route53
     */
    findOrCreateCertificate(params: {
        domainName: string;
        hostedZoneId?: string;
        subjectAlternativeNames?: string[];
        waitForValidation?: boolean;
    }): Promise<{
        certificateArn: string;
        isNew: boolean;
    }>;
    /**
     * Check if using external DNS provider
     */
    hasExternalDnsProvider(): boolean;
    /**
     * Get the DNS provider name if using external provider
     */
    getDnsProviderName(): string;
}
