export interface LoadBalancer {
    LoadBalancerArn?: string;
    DNSName?: string;
    CanonicalHostedZoneId?: string;
    CreatedTime?: string;
    LoadBalancerName?: string;
    Scheme?: 'internet-facing' | 'internal';
    VpcId?: string;
    State?: {
        Code?: 'active' | 'provisioning' | 'active_impaired' | 'failed';
        Reason?: string;
    };
    Type?: 'application' | 'network' | 'gateway';
    AvailabilityZones?: AvailabilityZone[];
    SecurityGroups?: string[];
    IpAddressType?: 'ipv4' | 'dualstack';
}
export interface AvailabilityZone {
    ZoneName?: string;
    SubnetId?: string;
    OutpostId?: string;
    LoadBalancerAddresses?: LoadBalancerAddress[];
}
export interface LoadBalancerAddress {
    IpAddress?: string;
    AllocationId?: string;
    PrivateIPv4Address?: string;
    IPv6Address?: string;
}
export interface TargetGroup {
    TargetGroupArn?: string;
    TargetGroupName?: string;
    Protocol?: string;
    Port?: number;
    VpcId?: string;
    HealthCheckProtocol?: string;
    HealthCheckPort?: string;
    HealthCheckEnabled?: boolean;
    HealthCheckIntervalSeconds?: number;
    HealthCheckTimeoutSeconds?: number;
    HealthyThresholdCount?: number;
    UnhealthyThresholdCount?: number;
    HealthCheckPath?: string;
    Matcher?: {
        HttpCode?: string;
        GrpcCode?: string;
    };
    LoadBalancerArns?: string[];
    TargetType?: 'instance' | 'ip' | 'lambda' | 'alb';
    ProtocolVersion?: string;
    IpAddressType?: 'ipv4' | 'ipv6';
}
export interface Listener {
    ListenerArn?: string;
    LoadBalancerArn?: string;
    Port?: number;
    Protocol?: string;
    Certificates?: Certificate[];
    SslPolicy?: string;
    DefaultActions?: Action[];
    AlpnPolicy?: string[];
}
export interface Certificate {
    CertificateArn?: string;
    IsDefault?: boolean;
}
export interface Action {
    Type?: 'forward' | 'redirect' | 'fixed-response' | 'authenticate-oidc' | 'authenticate-cognito';
    TargetGroupArn?: string;
    Order?: number;
    RedirectConfig?: {
        Protocol?: string;
        Port?: string;
        Host?: string;
        Path?: string;
        Query?: string;
        StatusCode?: 'HTTP_301' | 'HTTP_302';
    };
    FixedResponseConfig?: {
        MessageBody?: string;
        StatusCode?: string;
        ContentType?: string;
    };
    ForwardConfig?: {
        TargetGroups?: Array<{
            TargetGroupArn?: string;
            Weight?: number;
        }>;
        TargetGroupStickinessConfig?: {
            Enabled?: boolean;
            DurationSeconds?: number;
        };
    };
}
export interface Rule {
    RuleArn?: string;
    Priority?: string;
    Conditions?: Condition[];
    Actions?: Action[];
    IsDefault?: boolean;
}
export interface Condition {
    Field?: string;
    Values?: string[];
    HostHeaderConfig?: {
        Values?: string[];
    };
    PathPatternConfig?: {
        Values?: string[];
    };
    HttpHeaderConfig?: {
        HttpHeaderName?: string;
        Values?: string[];
    };
    QueryStringConfig?: {
        Values?: Array<{
            Key?: string;
            Value?: string;
        }>;
    };
    HttpRequestMethodConfig?: {
        Values?: string[];
    };
    SourceIpConfig?: {
        Values?: string[];
    };
}
export interface TargetHealthDescription {
    Target?: {
        Id?: string;
        Port?: number;
        AvailabilityZone?: string;
    };
    HealthCheckPort?: string;
    TargetHealth?: {
        State?: 'initial' | 'healthy' | 'unhealthy' | 'unused' | 'draining' | 'unavailable';
        Reason?: string;
        Description?: string;
    };
}
/**
 * ELBv2 client for managing Application, Network, and Gateway Load Balancers
 */
export declare class ELBv2Client {
    private client;
    private region;
    constructor(region?: string);
    /**
     * Describe load balancers
     */
    describeLoadBalancers(options?: {
        LoadBalancerArns?: string[];
        Names?: string[];
        Marker?: string;
        PageSize?: number;
    }): Promise<{
        LoadBalancers?: LoadBalancer[];
        NextMarker?: string;
    }>;
    /**
     * Describe target groups
     */
    describeTargetGroups(options?: {
        LoadBalancerArn?: string;
        TargetGroupArns?: string[];
        Names?: string[];
        Marker?: string;
        PageSize?: number;
    }): Promise<{
        TargetGroups?: TargetGroup[];
        NextMarker?: string;
    }>;
    /**
     * Describe target health
     */
    describeTargetHealth(options: {
        TargetGroupArn: string;
        Targets?: Array<{
            Id: string;
            Port?: number;
            AvailabilityZone?: string;
        }>;
    }): Promise<{
        TargetHealthDescriptions?: TargetHealthDescription[];
    }>;
    /**
     * Describe listeners
     */
    describeListeners(options?: {
        LoadBalancerArn?: string;
        ListenerArns?: string[];
        Marker?: string;
        PageSize?: number;
    }): Promise<{
        Listeners?: Listener[];
        NextMarker?: string;
    }>;
    /**
     * Describe rules for a listener
     */
    describeRules(options?: {
        ListenerArn?: string;
        RuleArns?: string[];
        Marker?: string;
        PageSize?: number;
    }): Promise<{
        Rules?: Rule[];
        NextMarker?: string;
    }>;
    /**
     * Describe load balancer attributes
     */
    describeLoadBalancerAttributes(loadBalancerArn: string): Promise<{
        Attributes?: Array<{
            Key: string;
            Value: string;
        }>;
    }>;
    /**
     * Describe target group attributes
     */
    describeTargetGroupAttributes(targetGroupArn: string): Promise<{
        Attributes?: Array<{
            Key: string;
            Value: string;
        }>;
    }>;
    /**
     * Create a load balancer
     */
    createLoadBalancer(options: {
        Name: string;
        Subnets?: string[];
        SubnetMappings?: Array<{
            SubnetId: string;
            AllocationId?: string;
            PrivateIPv4Address?: string;
            IPv6Address?: string;
        }>;
        SecurityGroups?: string[];
        Scheme?: 'internet-facing' | 'internal';
        Type?: 'application' | 'network' | 'gateway';
        IpAddressType?: 'ipv4' | 'dualstack';
        Tags?: Array<{
            Key: string;
            Value: string;
        }>;
    }): Promise<{
        LoadBalancers?: LoadBalancer[];
    }>;
    /**
     * Delete a load balancer
     */
    deleteLoadBalancer(loadBalancerArn: string): Promise<void>;
    /**
     * Create a target group
     */
    createTargetGroup(options: {
        Name: string;
        Protocol?: string;
        ProtocolVersion?: string;
        Port?: number;
        VpcId?: string;
        HealthCheckProtocol?: string;
        HealthCheckPort?: string;
        HealthCheckEnabled?: boolean;
        HealthCheckPath?: string;
        HealthCheckIntervalSeconds?: number;
        HealthCheckTimeoutSeconds?: number;
        HealthyThresholdCount?: number;
        UnhealthyThresholdCount?: number;
        Matcher?: {
            HttpCode?: string;
            GrpcCode?: string;
        };
        TargetType?: 'instance' | 'ip' | 'lambda' | 'alb';
        Tags?: Array<{
            Key: string;
            Value: string;
        }>;
        IpAddressType?: 'ipv4' | 'ipv6';
    }): Promise<{
        TargetGroups?: TargetGroup[];
    }>;
    /**
     * Delete a target group
     */
    deleteTargetGroup(targetGroupArn: string): Promise<void>;
    /**
     * Register targets with a target group
     */
    registerTargets(options: {
        TargetGroupArn: string;
        Targets: Array<{
            Id: string;
            Port?: number;
            AvailabilityZone?: string;
        }>;
    }): Promise<void>;
    /**
     * Deregister targets from a target group
     */
    deregisterTargets(options: {
        TargetGroupArn: string;
        Targets: Array<{
            Id: string;
            Port?: number;
            AvailabilityZone?: string;
        }>;
    }): Promise<void>;
    /**
     * Create a listener
     */
    createListener(options: {
        LoadBalancerArn: string;
        Protocol?: string;
        Port: number;
        SslPolicy?: string;
        Certificates?: Array<{
            CertificateArn: string;
        }>;
        DefaultActions: Array<{
            Type: 'forward' | 'redirect' | 'fixed-response';
            TargetGroupArn?: string;
            Order?: number;
            RedirectConfig?: {
                Protocol?: string;
                Port?: string;
                Host?: string;
                Path?: string;
                Query?: string;
                StatusCode: 'HTTP_301' | 'HTTP_302';
            };
            FixedResponseConfig?: {
                MessageBody?: string;
                StatusCode: string;
                ContentType?: string;
            };
        }>;
        AlpnPolicy?: string[];
        Tags?: Array<{
            Key: string;
            Value: string;
        }>;
    }): Promise<{
        Listeners?: Listener[];
    }>;
    /**
     * Delete a listener
     */
    deleteListener(listenerArn: string): Promise<void>;
    /**
     * Modify listener
     */
    modifyListener(options: {
        ListenerArn: string;
        Port?: number;
        Protocol?: string;
        SslPolicy?: string;
        Certificates?: Array<{
            CertificateArn: string;
        }>;
        DefaultActions?: Action[];
        AlpnPolicy?: string[];
    }): Promise<{
        Listeners?: Listener[];
    }>;
    /**
     * Build form URL encoded body for ELBv2 API
     */
    private buildFormBody;
    /**
     * Normalize the parsed XML result from AWS API
     * The client parses XML to JSON, so we need to extract the result
     */
    private normalizeResult;
    /**
     * Normalize arrays in the response
     * AWS XML parsing sometimes returns single items as objects instead of arrays
     */
    private normalizeArrays;
}
