import * as pulumi from "@pulumi/pulumi";
import * as inputs from "./types/input";
import * as outputs from "./types/output";
/**
 * Get information about a Vultr load balancer.
 *
 * ## Example Usage
 *
 * Create a new load balancer:
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as vultr from "@ediri/vultr";
 *
 * const lb = new vultr.LoadBalancer("lb", {
 *     balancingAlgorithm: "roundrobin",
 *     forwardingRules: [{
 *         backendPort: 81,
 *         backendProtocol: "http",
 *         frontendPort: 82,
 *         frontendProtocol: "http",
 *     }],
 *     healthCheck: {
 *         checkInterval: 3,
 *         healthyThreshold: 4,
 *         path: "/test",
 *         port: 8080,
 *         protocol: "http",
 *         responseTimeout: 1,
 *         unhealthyThreshold: 2,
 *     },
 *     label: "vultr-load-balancer",
 *     region: "ewr",
 * });
 * ```
 *
 * ## Import
 *
 * Load Balancers can be imported using the load balancer `ID`, e.g.
 *
 * ```sh
 * $ pulumi import vultr:index/loadBalancer:LoadBalancer lb b6a859c5-b299-49dd-8888-b1abbc517d08
 * ```
 */
export declare class LoadBalancer extends pulumi.CustomResource {
    /**
     * Get an existing LoadBalancer resource's state with the given name, ID, and optional extra
     * properties used to qualify the lookup.
     *
     * @param name The _unique_ name of the resulting resource.
     * @param id The _unique_ provider ID of the resource to lookup.
     * @param state Any extra arguments used during the lookup.
     * @param opts Optional settings to control the behavior of the CustomResource.
     */
    static get(name: string, id: pulumi.Input<pulumi.ID>, state?: LoadBalancerState, opts?: pulumi.CustomResourceOptions): LoadBalancer;
    /**
     * Returns true if the given object is an instance of LoadBalancer.  This is designed to work even
     * when multiple copies of the Pulumi SDK have been loaded into the same process.
     */
    static isInstance(obj: any): obj is LoadBalancer;
    /**
     * Array of instances that are currently attached to the load balancer.
     */
    readonly attachedInstances: pulumi.Output<string[]>;
    /**
     * The balancing algorithm for your load balancer. Options are `roundrobin` or `leastconn`. Default value is `roundrobin`
     */
    readonly balancingAlgorithm: pulumi.Output<string>;
    /**
     * Name for your given sticky session.
     */
    readonly cookieName: pulumi.Output<string | undefined>;
    /**
     * Defines the firewall rules for a load balancer.
     */
    readonly firewallRules: pulumi.Output<outputs.LoadBalancerFirewallRule[] | undefined>;
    /**
     * List of forwarding rules for a load balancer. The configuration of a `forwardingRules` is listened below.
     */
    readonly forwardingRules: pulumi.Output<outputs.LoadBalancerForwardingRule[]>;
    /**
     * Boolean value that indicates if SSL is enabled.
     */
    readonly hasSsl: pulumi.Output<boolean>;
    /**
     * A block that defines the way load balancers should check for health. The configuration of a `healthCheck` is listed below.
     */
    readonly healthCheck: pulumi.Output<outputs.LoadBalancerHealthCheck>;
    /**
     * IPv4 address for your load balancer.
     */
    readonly ipv4: pulumi.Output<string>;
    /**
     * IPv6 address for your load balancer.
     */
    readonly ipv6: pulumi.Output<string>;
    /**
     * The load balancer's label.
     */
    readonly label: pulumi.Output<string | undefined>;
    /**
     * Boolean value that indicates if Proxy Protocol is enabled.
     */
    readonly proxyProtocol: pulumi.Output<boolean | undefined>;
    /**
     * The region your load balancer is deployed in.
     */
    readonly region: pulumi.Output<string>;
    /**
     * A block that supplies your ssl configuration to be used with HTTPS. The configuration of a `ssl` is listed below.
     */
    readonly ssl: pulumi.Output<outputs.LoadBalancerSsl | undefined>;
    /**
     * Boolean value that indicates if HTTP calls will be redirected to HTTPS.
     */
    readonly sslRedirect: pulumi.Output<boolean | undefined>;
    /**
     * Current status for the load balancer
     */
    readonly status: pulumi.Output<string>;
    /**
     * A VPC ID that the load balancer should be attached to.
     */
    readonly vpc: pulumi.Output<string | undefined>;
    /**
     * Create a LoadBalancer resource with the given unique name, arguments, and options.
     *
     * @param name The _unique_ name of the resource.
     * @param args The arguments to use to populate this resource's properties.
     * @param opts A bag of options that control this resource's behavior.
     */
    constructor(name: string, args: LoadBalancerArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering LoadBalancer resources.
 */
export interface LoadBalancerState {
    /**
     * Array of instances that are currently attached to the load balancer.
     */
    attachedInstances?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The balancing algorithm for your load balancer. Options are `roundrobin` or `leastconn`. Default value is `roundrobin`
     */
    balancingAlgorithm?: pulumi.Input<string>;
    /**
     * Name for your given sticky session.
     */
    cookieName?: pulumi.Input<string>;
    /**
     * Defines the firewall rules for a load balancer.
     */
    firewallRules?: pulumi.Input<pulumi.Input<inputs.LoadBalancerFirewallRule>[]>;
    /**
     * List of forwarding rules for a load balancer. The configuration of a `forwardingRules` is listened below.
     */
    forwardingRules?: pulumi.Input<pulumi.Input<inputs.LoadBalancerForwardingRule>[]>;
    /**
     * Boolean value that indicates if SSL is enabled.
     */
    hasSsl?: pulumi.Input<boolean>;
    /**
     * A block that defines the way load balancers should check for health. The configuration of a `healthCheck` is listed below.
     */
    healthCheck?: pulumi.Input<inputs.LoadBalancerHealthCheck>;
    /**
     * IPv4 address for your load balancer.
     */
    ipv4?: pulumi.Input<string>;
    /**
     * IPv6 address for your load balancer.
     */
    ipv6?: pulumi.Input<string>;
    /**
     * The load balancer's label.
     */
    label?: pulumi.Input<string>;
    /**
     * Boolean value that indicates if Proxy Protocol is enabled.
     */
    proxyProtocol?: pulumi.Input<boolean>;
    /**
     * The region your load balancer is deployed in.
     */
    region?: pulumi.Input<string>;
    /**
     * A block that supplies your ssl configuration to be used with HTTPS. The configuration of a `ssl` is listed below.
     */
    ssl?: pulumi.Input<inputs.LoadBalancerSsl>;
    /**
     * Boolean value that indicates if HTTP calls will be redirected to HTTPS.
     */
    sslRedirect?: pulumi.Input<boolean>;
    /**
     * Current status for the load balancer
     */
    status?: pulumi.Input<string>;
    /**
     * A VPC ID that the load balancer should be attached to.
     */
    vpc?: pulumi.Input<string>;
}
/**
 * The set of arguments for constructing a LoadBalancer resource.
 */
export interface LoadBalancerArgs {
    /**
     * Array of instances that are currently attached to the load balancer.
     */
    attachedInstances?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The balancing algorithm for your load balancer. Options are `roundrobin` or `leastconn`. Default value is `roundrobin`
     */
    balancingAlgorithm?: pulumi.Input<string>;
    /**
     * Name for your given sticky session.
     */
    cookieName?: pulumi.Input<string>;
    /**
     * Defines the firewall rules for a load balancer.
     */
    firewallRules?: pulumi.Input<pulumi.Input<inputs.LoadBalancerFirewallRule>[]>;
    /**
     * List of forwarding rules for a load balancer. The configuration of a `forwardingRules` is listened below.
     */
    forwardingRules: pulumi.Input<pulumi.Input<inputs.LoadBalancerForwardingRule>[]>;
    /**
     * A block that defines the way load balancers should check for health. The configuration of a `healthCheck` is listed below.
     */
    healthCheck?: pulumi.Input<inputs.LoadBalancerHealthCheck>;
    /**
     * The load balancer's label.
     */
    label?: pulumi.Input<string>;
    /**
     * Boolean value that indicates if Proxy Protocol is enabled.
     */
    proxyProtocol?: pulumi.Input<boolean>;
    /**
     * The region your load balancer is deployed in.
     */
    region: pulumi.Input<string>;
    /**
     * A block that supplies your ssl configuration to be used with HTTPS. The configuration of a `ssl` is listed below.
     */
    ssl?: pulumi.Input<inputs.LoadBalancerSsl>;
    /**
     * Boolean value that indicates if HTTP calls will be redirected to HTTPS.
     */
    sslRedirect?: pulumi.Input<boolean>;
    /**
     * A VPC ID that the load balancer should be attached to.
     */
    vpc?: pulumi.Input<string>;
}