import * as pulumi from "@pulumi/pulumi";
import * as inputs from "./types/input";
import * as outputs from "./types/output";
/**
 * This resource represents [Managed Load Balancer](https://upcloud.com/products/managed-load-balancer) service.
 *
 * ## Example Usage
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as upcloud from "@upcloud/pulumi-upcloud";
 *
 * const config = new pulumi.Config();
 * const lbZone = config.get("lbZone") || "fi-hel2";
 * const lbNetwork = new upcloud.Network("lb_network", {
 *     name: "lb-test-net",
 *     zone: lbZone,
 *     ipNetwork: {
 *         address: "10.0.0.0/24",
 *         dhcp: true,
 *         family: "IPv4",
 *     },
 * });
 * const lb = new upcloud.Loadbalancer("lb", {
 *     configuredStatus: "started",
 *     name: "lb-test",
 *     plan: "development",
 *     zone: lbZone,
 *     networks: [
 *         {
 *             name: "Private-Net",
 *             type: "private",
 *             family: "IPv4",
 *             network: upcloudNetwork.lbNetwork.id,
 *         },
 *         {
 *             name: "Public-Net",
 *             type: "public",
 *             family: "IPv4",
 *         },
 *     ],
 * });
 * ```
 */
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;
    /**
     * Backends are groups of customer servers whose traffic should be balanced.
     */
    readonly backends: pulumi.Output<string[]>;
    /**
     * The service configured status indicates the service's current intended status. Managed by the customer.
     */
    readonly configuredStatus: pulumi.Output<string>;
    /**
     * DNS name of the load balancer
     *
     * @deprecated Use 'networks' to get network DNS name
     */
    readonly dnsName: pulumi.Output<string>;
    /**
     * Frontends receive the traffic before dispatching it to the backends.
     */
    readonly frontends: pulumi.Output<string[]>;
    /**
     * Floating IP addresses connected to the load balancer.
     */
    readonly ipAddresses: pulumi.Output<outputs.LoadbalancerIpAddress[] | undefined>;
    /**
     * User defined key-value pairs to classify the load balancer.
     */
    readonly labels: pulumi.Output<{
        [key: string]: string;
    }>;
    /**
     * The day of the week on which maintenance will be performed. If not provided, we will randomly select a weekend day. Valid values `monday|tuesday|wednesday|thursday|friday|saturday|sunday`.
     */
    readonly maintenanceDow: pulumi.Output<string>;
    /**
     * The time at which the maintenance will begin in UTC. A 2-hour timeframe has been allocated for maintenance. During this period, the multi-node production plans will not experience any downtime, while the one-node plans will have a downtime of 1-2 minutes. If not provided, we will randomly select an off-peak time. Needs to be a valid time format in UTC HH:MM:SSZ, for example `20:01:01Z`.
     */
    readonly maintenanceTime: pulumi.Output<string>;
    /**
     * The name of the service. Must be unique within customer account.
     */
    readonly name: pulumi.Output<string>;
    /**
     * Private network UUID where traffic will be routed. Must reside in load balancer zone.
     *
     * @deprecated Use 'networks' to define networks attached to load balancer
     */
    readonly network: pulumi.Output<string>;
    /**
     * Attached Networks from where traffic consumed and routed. Private networks must reside in loadbalancer zone.
     */
    readonly networks: pulumi.Output<outputs.LoadbalancerNetwork[] | undefined>;
    /**
     * Nodes are instances running load balancer service
     */
    readonly nodes: pulumi.Output<outputs.LoadbalancerNode[]>;
    /**
     * The service operational state indicates the service's current operational, effective state. Managed by the system.
     */
    readonly operationalState: pulumi.Output<string>;
    /**
     * Plan which the service will have. You can list available load balancer plans with `upctl loadbalancer plans`
     */
    readonly plan: pulumi.Output<string>;
    /**
     * Domain Name Resolvers.
     */
    readonly resolvers: pulumi.Output<string[]>;
    /**
     * Zone in which the service will be hosted, e.g. `fi-hel1`. You can list available zones with `upctl zone list`.
     */
    readonly zone: pulumi.Output<string>;
    /**
     * 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 {
    /**
     * Backends are groups of customer servers whose traffic should be balanced.
     */
    backends?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The service configured status indicates the service's current intended status. Managed by the customer.
     */
    configuredStatus?: pulumi.Input<string>;
    /**
     * DNS name of the load balancer
     *
     * @deprecated Use 'networks' to get network DNS name
     */
    dnsName?: pulumi.Input<string>;
    /**
     * Frontends receive the traffic before dispatching it to the backends.
     */
    frontends?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Floating IP addresses connected to the load balancer.
     */
    ipAddresses?: pulumi.Input<pulumi.Input<inputs.LoadbalancerIpAddress>[]>;
    /**
     * User defined key-value pairs to classify the load balancer.
     */
    labels?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * The day of the week on which maintenance will be performed. If not provided, we will randomly select a weekend day. Valid values `monday|tuesday|wednesday|thursday|friday|saturday|sunday`.
     */
    maintenanceDow?: pulumi.Input<string>;
    /**
     * The time at which the maintenance will begin in UTC. A 2-hour timeframe has been allocated for maintenance. During this period, the multi-node production plans will not experience any downtime, while the one-node plans will have a downtime of 1-2 minutes. If not provided, we will randomly select an off-peak time. Needs to be a valid time format in UTC HH:MM:SSZ, for example `20:01:01Z`.
     */
    maintenanceTime?: pulumi.Input<string>;
    /**
     * The name of the service. Must be unique within customer account.
     */
    name?: pulumi.Input<string>;
    /**
     * Private network UUID where traffic will be routed. Must reside in load balancer zone.
     *
     * @deprecated Use 'networks' to define networks attached to load balancer
     */
    network?: pulumi.Input<string>;
    /**
     * Attached Networks from where traffic consumed and routed. Private networks must reside in loadbalancer zone.
     */
    networks?: pulumi.Input<pulumi.Input<inputs.LoadbalancerNetwork>[]>;
    /**
     * Nodes are instances running load balancer service
     */
    nodes?: pulumi.Input<pulumi.Input<inputs.LoadbalancerNode>[]>;
    /**
     * The service operational state indicates the service's current operational, effective state. Managed by the system.
     */
    operationalState?: pulumi.Input<string>;
    /**
     * Plan which the service will have. You can list available load balancer plans with `upctl loadbalancer plans`
     */
    plan?: pulumi.Input<string>;
    /**
     * Domain Name Resolvers.
     */
    resolvers?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Zone in which the service will be hosted, e.g. `fi-hel1`. You can list available zones with `upctl zone list`.
     */
    zone?: pulumi.Input<string>;
}
/**
 * The set of arguments for constructing a Loadbalancer resource.
 */
export interface LoadbalancerArgs {
    /**
     * The service configured status indicates the service's current intended status. Managed by the customer.
     */
    configuredStatus?: pulumi.Input<string>;
    /**
     * Floating IP addresses connected to the load balancer.
     */
    ipAddresses?: pulumi.Input<pulumi.Input<inputs.LoadbalancerIpAddress>[]>;
    /**
     * User defined key-value pairs to classify the load balancer.
     */
    labels?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * The day of the week on which maintenance will be performed. If not provided, we will randomly select a weekend day. Valid values `monday|tuesday|wednesday|thursday|friday|saturday|sunday`.
     */
    maintenanceDow?: pulumi.Input<string>;
    /**
     * The time at which the maintenance will begin in UTC. A 2-hour timeframe has been allocated for maintenance. During this period, the multi-node production plans will not experience any downtime, while the one-node plans will have a downtime of 1-2 minutes. If not provided, we will randomly select an off-peak time. Needs to be a valid time format in UTC HH:MM:SSZ, for example `20:01:01Z`.
     */
    maintenanceTime?: pulumi.Input<string>;
    /**
     * The name of the service. Must be unique within customer account.
     */
    name?: pulumi.Input<string>;
    /**
     * Private network UUID where traffic will be routed. Must reside in load balancer zone.
     *
     * @deprecated Use 'networks' to define networks attached to load balancer
     */
    network?: pulumi.Input<string>;
    /**
     * Attached Networks from where traffic consumed and routed. Private networks must reside in loadbalancer zone.
     */
    networks?: pulumi.Input<pulumi.Input<inputs.LoadbalancerNetwork>[]>;
    /**
     * Plan which the service will have. You can list available load balancer plans with `upctl loadbalancer plans`
     */
    plan: pulumi.Input<string>;
    /**
     * Zone in which the service will be hosted, e.g. `fi-hel1`. You can list available zones with `upctl zone list`.
     */
    zone: pulumi.Input<string>;
}