import * as pulumi from "@pulumi/pulumi";
import * as inputs from "./types/input";
import * as outputs from "./types/output";
/**
 * ## # f5bigip.GtmPool Resource
 *
 * Provides a BIG-IP GTM (Global Traffic Manager) Pool resource. This resource allows you to configure and manage GTM Pool objects on a BIG-IP system.
 *
 * ## Description
 *
 * A GTM pool is a collection of virtual servers or other pool members that can be distributed across multiple data centers. GTM pools are used by WideIPs to intelligently distribute DNS traffic based on various load balancing algorithms and health monitoring.
 *
 * GTM Pool types correspond to different DNS record types:
 * - **a**: IPv4 address pools
 * - **aaaa**: IPv6 address pools
 * - **cname**: Canonical name pools
 * - **mx**: Mail exchange pools
 * - **naptr**: Naming authority pointer pools
 * - **srv**: Service locator pools
 *
 * ## Example Usage
 *
 * ### Basic Pool
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const example = new f5bigip.GtmPool("example", {
 *     name: "my_pool",
 *     type: "a",
 *     partition: "Common",
 *     loadBalancingMode: "round-robin",
 *     monitor: "/Common/https",
 * });
 * ```
 *
 * ### Pool with Members
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const withMembers = new f5bigip.GtmPool("with_members", {
 *     name: "app_pool",
 *     type: "a",
 *     partition: "Common",
 *     loadBalancingMode: "round-robin",
 *     monitor: "/Common/https",
 *     ttl: 30,
 *     members: [
 *         {
 *             name: "server1:/Common/vs_app",
 *             enabled: true,
 *             ratio: 1,
 *             memberOrder: 0,
 *         },
 *         {
 *             name: "server2:/Common/vs_app",
 *             enabled: true,
 *             ratio: 1,
 *             memberOrder: 1,
 *         },
 *     ],
 * });
 * ```
 *
 * ### Advanced Pool Configuration
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const advanced = new f5bigip.GtmPool("advanced", {
 *     name: "advanced_pool",
 *     type: "a",
 *     partition: "Common",
 *     loadBalancingMode: "round-robin",
 *     alternateMode: "topology",
 *     fallbackMode: "return-to-dns",
 *     fallbackIp: "192.0.2.1",
 *     maxAnswersReturned: 2,
 *     ttl: 60,
 *     monitor: "/Common/https",
 *     verifyMemberAvailability: "enabled",
 *     qosHitRatio: 10,
 *     qosHops: 5,
 *     qosKilobytesSecond: 5,
 *     qosLcs: 50,
 *     qosPacketRate: 5,
 *     qosRtt: 100,
 *     limitMaxConnections: 5000,
 *     limitMaxConnectionsStatus: "enabled",
 *     limitMaxBps: 100000000,
 *     limitMaxBpsStatus: "enabled",
 *     minMembersUpMode: "at-least",
 *     minMembersUpValue: 2,
 *     members: [
 *         {
 *             name: "server1:/Common/vs_app",
 *             enabled: true,
 *             ratio: 2,
 *             memberOrder: 0,
 *             monitor: "default",
 *             limitMaxConnections: 2000,
 *             limitMaxConnectionsStatus: "enabled",
 *         },
 *         {
 *             name: "server2:/Common/vs_app",
 *             enabled: true,
 *             ratio: 1,
 *             memberOrder: 1,
 *         },
 *     ],
 * });
 * ```
 *
 * ## Notes
 *
 * ### Pool Member Name Format
 *
 * Pool members must be specified in the format: `<server_name>:<virtual_server_name>`
 *
 * Examples:
 * - `server1:/Common/vs_app` - References virtual server `vsApp` on server `server1`
 * - `dc1_server:/Prod/app_vs` - References virtual server `appVs` in partition `Prod` on server `dc1Server`
 *
 * The server and virtual server must already exist in the GTM configuration.
 *
 * ### Load Balancing Modes
 *
 * The `loadBalancingMode` determines how GTM distributes DNS queries across pool members:
 *
 * - **round-robin**: Distributes queries equally across all available members
 * - **ratio**: Distributes queries based on member ratios
 * - **topology**: Uses topology records to determine the best member
 * - **global-availability**: Considers member availability and load
 * - **virtual-server-capacity**: Based on virtual server capacity
 * - **least-connections**: Selects member with fewest active connections
 * - **lowest-round-trip-time**: Selects member with lowest RTT
 * - **fewest-hops**: Selects member with fewest network hops
 * - **packet-rate**: Based on packet transmission rate
 * - **cpu**: Based on CPU utilization
 * - **completion-rate**: Based on connection completion rate
 * - **quality-of-service**: Based on QoS metrics
 * - **kilobytes-per-second**: Based on throughput
 * - **dynamic-ratio**: Dynamically adjusts member ratios
 * - **drop-packet**: Drops DNS packets (used for testing)
 * - **fallback-ip**: Returns a fallback IP address
 * - **virtual-server-score**: Based on virtual server scores
 *
 * ### QoS Weights
 *
 * QoS (Quality of Service) weights are used when the load balancing mode is set to `quality-of-service`. Higher weights give more importance to specific metrics:
 *
 * - **qos_hit_ratio**: Cache hit ratio
 * - **qos_hops**: Number of router hops
 * - **qos_kilobytes_second**: Data throughput
 * - **qos_lcs**: Link capacity score
 * - **qos_packet_rate**: Packet transmission rate
 * - **qos_rtt**: Round trip time
 * - **qos_topology**: Topology distance
 * - **qos_vs_capacity**: Virtual server capacity
 * - **qos_vs_score**: Virtual server score
 *
 * ### Connection Limits
 *
 * Connection limits can be set at both the pool level and individual member level:
 * - Pool-level limits apply to the entire pool
 * - Member-level limits apply to individual members
 * - Both limits must have their corresponding `_status` field set to `enabled` to take effect
 *
 * ### Minimum Members
 *
 * The `minMembersUpMode` and `minMembersUpValue` work together:
 * - **off**: No minimum requirement
 * - **at-least**: At least `minMembersUpValue` members must be up
 * - **percent**: At least `minMembersUpValue` percent of members must be up
 *
 * Example: If you have 5 members and set `minMembersUpMode = "at-least"` and `minMembersUpValue = 2`, the pool will be marked down if fewer than 2 members are available.
 *
 * ## API Endpoints
 *
 * This resource interacts with the following BIG-IP API endpoints:
 *
 * - `GET /mgmt/tm/gtm/pool/<type>/<name>?expandSubcollections=true` - Read pool configuration
 * - `POST /mgmt/tm/gtm/pool/<type>` - Create pool
 * - `PUT /mgmt/tm/gtm/pool/<type>/<name>` - Update pool configuration
 * - `DELETE /mgmt/tm/gtm/pool/<type>/<name>` - Delete pool
 *
 * ## Related Resources
 *
 * - `f5bigip.GtmWideip` - Manages GTM WideIPs that reference pools
 * - `f5bigip.GtmServer` - Manages GTM servers that contain virtual servers
 * - `f5bigip.GtmDatacenter` - Manages GTM data centers
 * - `bigipGtmMonitor` - Manages GTM health monitors
 *
 * ## Import
 *
 * GTM Pool resources can be imported using the format `/<partition>/<name>:<type>`. For example:
 *
 * ```sh
 * $ pulumi import f5bigip:index/gtmPool:GtmPool example /Common/my_pool:a
 * ```
 */
export declare class GtmPool extends pulumi.CustomResource {
    /**
     * Get an existing GtmPool 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?: GtmPoolState, opts?: pulumi.CustomResourceOptions): GtmPool;
    /**
     * Returns true if the given object is an instance of GtmPool.  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 GtmPool;
    /**
     * Specifies the load balancing mode to use if the preferred and alternate modes are unsuccessful
     */
    readonly alternateMode: pulumi.Output<string | undefined>;
    /**
     * Disabled state of the pool
     */
    readonly disabled: pulumi.Output<boolean | undefined>;
    /**
     * Enables or disables the dynamic ratio load balancing algorithm
     */
    readonly dynamicRatio: pulumi.Output<string | undefined>;
    /**
     * Enable or disable the pool
     */
    readonly enabled: pulumi.Output<boolean | undefined>;
    /**
     * Specifies the IPv4 or IPv6 address of the server to which the system directs requests when it cannot use one of its pools
     */
    readonly fallbackIp: pulumi.Output<string | undefined>;
    /**
     * Specifies the load balancing mode that the system uses if the pool's preferred and alternate modes are unsuccessful
     */
    readonly fallbackMode: pulumi.Output<string | undefined>;
    /**
     * Specifies the maximum allowable data throughput rate in bits per second
     */
    readonly limitMaxBps: pulumi.Output<number | undefined>;
    /**
     * Enables or disables the limitMaxBps option
     */
    readonly limitMaxBpsStatus: pulumi.Output<string | undefined>;
    /**
     * Specifies the maximum number of concurrent connections
     */
    readonly limitMaxConnections: pulumi.Output<number | undefined>;
    /**
     * Enables or disables the limitMaxConnections option
     */
    readonly limitMaxConnectionsStatus: pulumi.Output<string | undefined>;
    /**
     * Specifies the maximum allowable data transfer rate in packets per second
     */
    readonly limitMaxPps: pulumi.Output<number | undefined>;
    /**
     * Enables or disables the limitMaxPps option
     */
    readonly limitMaxPpsStatus: pulumi.Output<string | undefined>;
    /**
     * Specifies the preferred load balancing mode for the pool
     */
    readonly loadBalancingMode: pulumi.Output<string | undefined>;
    /**
     * Specifies whether manual resume is enabled
     */
    readonly manualResume: pulumi.Output<string | undefined>;
    /**
     * Specifies the maximum number of available virtual servers that the system lists in a response
     */
    readonly maxAnswersReturned: pulumi.Output<number | undefined>;
    readonly members: pulumi.Output<outputs.GtmPoolMember[] | undefined>;
    /**
     * Specifies whether the minimum number of members must be up for the pool to be active
     */
    readonly minMembersUpMode: pulumi.Output<string | undefined>;
    /**
     * Specifies the minimum number of pool members that must be up
     */
    readonly minMembersUpValue: pulumi.Output<number | undefined>;
    /**
     * Specifies the health monitor for the pool
     */
    readonly monitor: pulumi.Output<string | undefined>;
    /**
     * Name of the GTM pool
     */
    readonly name: pulumi.Output<string>;
    /**
     * Partition in which the pool resides
     */
    readonly partition: pulumi.Output<string | undefined>;
    /**
     * Specifies the weight for QoS hit ratio
     */
    readonly qosHitRatio: pulumi.Output<number | undefined>;
    /**
     * Specifies the weight for QoS hops
     */
    readonly qosHops: pulumi.Output<number | undefined>;
    /**
     * Specifies the weight for QoS kilobytes per second
     */
    readonly qosKilobytesSecond: pulumi.Output<number | undefined>;
    /**
     * Specifies the weight for QoS link capacity
     */
    readonly qosLcs: pulumi.Output<number | undefined>;
    /**
     * Specifies the weight for QoS packet rate
     */
    readonly qosPacketRate: pulumi.Output<number | undefined>;
    /**
     * Specifies the weight for QoS round trip time
     */
    readonly qosRtt: pulumi.Output<number | undefined>;
    /**
     * Specifies the weight for QoS topology
     */
    readonly qosTopology: pulumi.Output<number | undefined>;
    /**
     * Specifies the weight for QoS virtual server capacity
     */
    readonly qosVsCapacity: pulumi.Output<number | undefined>;
    /**
     * Specifies the weight for QoS virtual server score
     */
    readonly qosVsScore: pulumi.Output<number | undefined>;
    /**
     * Specifies the time to live (TTL) for the pool
     */
    readonly ttl: pulumi.Output<number | undefined>;
    /**
     * Type of GTM pool (a, aaaa, cname, mx, naptr, srv)
     */
    readonly type: pulumi.Output<string>;
    /**
     * Specifies whether the system verifies the availability of pool members before sending traffic
     */
    readonly verifyMemberAvailability: pulumi.Output<string | undefined>;
    /**
     * Create a GtmPool 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: GtmPoolArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering GtmPool resources.
 */
export interface GtmPoolState {
    /**
     * Specifies the load balancing mode to use if the preferred and alternate modes are unsuccessful
     */
    alternateMode?: pulumi.Input<string | undefined>;
    /**
     * Disabled state of the pool
     */
    disabled?: pulumi.Input<boolean | undefined>;
    /**
     * Enables or disables the dynamic ratio load balancing algorithm
     */
    dynamicRatio?: pulumi.Input<string | undefined>;
    /**
     * Enable or disable the pool
     */
    enabled?: pulumi.Input<boolean | undefined>;
    /**
     * Specifies the IPv4 or IPv6 address of the server to which the system directs requests when it cannot use one of its pools
     */
    fallbackIp?: pulumi.Input<string | undefined>;
    /**
     * Specifies the load balancing mode that the system uses if the pool's preferred and alternate modes are unsuccessful
     */
    fallbackMode?: pulumi.Input<string | undefined>;
    /**
     * Specifies the maximum allowable data throughput rate in bits per second
     */
    limitMaxBps?: pulumi.Input<number | undefined>;
    /**
     * Enables or disables the limitMaxBps option
     */
    limitMaxBpsStatus?: pulumi.Input<string | undefined>;
    /**
     * Specifies the maximum number of concurrent connections
     */
    limitMaxConnections?: pulumi.Input<number | undefined>;
    /**
     * Enables or disables the limitMaxConnections option
     */
    limitMaxConnectionsStatus?: pulumi.Input<string | undefined>;
    /**
     * Specifies the maximum allowable data transfer rate in packets per second
     */
    limitMaxPps?: pulumi.Input<number | undefined>;
    /**
     * Enables or disables the limitMaxPps option
     */
    limitMaxPpsStatus?: pulumi.Input<string | undefined>;
    /**
     * Specifies the preferred load balancing mode for the pool
     */
    loadBalancingMode?: pulumi.Input<string | undefined>;
    /**
     * Specifies whether manual resume is enabled
     */
    manualResume?: pulumi.Input<string | undefined>;
    /**
     * Specifies the maximum number of available virtual servers that the system lists in a response
     */
    maxAnswersReturned?: pulumi.Input<number | undefined>;
    members?: pulumi.Input<pulumi.Input<inputs.GtmPoolMember>[] | undefined>;
    /**
     * Specifies whether the minimum number of members must be up for the pool to be active
     */
    minMembersUpMode?: pulumi.Input<string | undefined>;
    /**
     * Specifies the minimum number of pool members that must be up
     */
    minMembersUpValue?: pulumi.Input<number | undefined>;
    /**
     * Specifies the health monitor for the pool
     */
    monitor?: pulumi.Input<string | undefined>;
    /**
     * Name of the GTM pool
     */
    name?: pulumi.Input<string | undefined>;
    /**
     * Partition in which the pool resides
     */
    partition?: pulumi.Input<string | undefined>;
    /**
     * Specifies the weight for QoS hit ratio
     */
    qosHitRatio?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS hops
     */
    qosHops?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS kilobytes per second
     */
    qosKilobytesSecond?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS link capacity
     */
    qosLcs?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS packet rate
     */
    qosPacketRate?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS round trip time
     */
    qosRtt?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS topology
     */
    qosTopology?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS virtual server capacity
     */
    qosVsCapacity?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS virtual server score
     */
    qosVsScore?: pulumi.Input<number | undefined>;
    /**
     * Specifies the time to live (TTL) for the pool
     */
    ttl?: pulumi.Input<number | undefined>;
    /**
     * Type of GTM pool (a, aaaa, cname, mx, naptr, srv)
     */
    type?: pulumi.Input<string | undefined>;
    /**
     * Specifies whether the system verifies the availability of pool members before sending traffic
     */
    verifyMemberAvailability?: pulumi.Input<string | undefined>;
}
/**
 * The set of arguments for constructing a GtmPool resource.
 */
export interface GtmPoolArgs {
    /**
     * Specifies the load balancing mode to use if the preferred and alternate modes are unsuccessful
     */
    alternateMode?: pulumi.Input<string | undefined>;
    /**
     * Disabled state of the pool
     */
    disabled?: pulumi.Input<boolean | undefined>;
    /**
     * Enables or disables the dynamic ratio load balancing algorithm
     */
    dynamicRatio?: pulumi.Input<string | undefined>;
    /**
     * Enable or disable the pool
     */
    enabled?: pulumi.Input<boolean | undefined>;
    /**
     * Specifies the IPv4 or IPv6 address of the server to which the system directs requests when it cannot use one of its pools
     */
    fallbackIp?: pulumi.Input<string | undefined>;
    /**
     * Specifies the load balancing mode that the system uses if the pool's preferred and alternate modes are unsuccessful
     */
    fallbackMode?: pulumi.Input<string | undefined>;
    /**
     * Specifies the maximum allowable data throughput rate in bits per second
     */
    limitMaxBps?: pulumi.Input<number | undefined>;
    /**
     * Enables or disables the limitMaxBps option
     */
    limitMaxBpsStatus?: pulumi.Input<string | undefined>;
    /**
     * Specifies the maximum number of concurrent connections
     */
    limitMaxConnections?: pulumi.Input<number | undefined>;
    /**
     * Enables or disables the limitMaxConnections option
     */
    limitMaxConnectionsStatus?: pulumi.Input<string | undefined>;
    /**
     * Specifies the maximum allowable data transfer rate in packets per second
     */
    limitMaxPps?: pulumi.Input<number | undefined>;
    /**
     * Enables or disables the limitMaxPps option
     */
    limitMaxPpsStatus?: pulumi.Input<string | undefined>;
    /**
     * Specifies the preferred load balancing mode for the pool
     */
    loadBalancingMode?: pulumi.Input<string | undefined>;
    /**
     * Specifies whether manual resume is enabled
     */
    manualResume?: pulumi.Input<string | undefined>;
    /**
     * Specifies the maximum number of available virtual servers that the system lists in a response
     */
    maxAnswersReturned?: pulumi.Input<number | undefined>;
    members?: pulumi.Input<pulumi.Input<inputs.GtmPoolMember>[] | undefined>;
    /**
     * Specifies whether the minimum number of members must be up for the pool to be active
     */
    minMembersUpMode?: pulumi.Input<string | undefined>;
    /**
     * Specifies the minimum number of pool members that must be up
     */
    minMembersUpValue?: pulumi.Input<number | undefined>;
    /**
     * Specifies the health monitor for the pool
     */
    monitor?: pulumi.Input<string | undefined>;
    /**
     * Name of the GTM pool
     */
    name: pulumi.Input<string>;
    /**
     * Partition in which the pool resides
     */
    partition?: pulumi.Input<string | undefined>;
    /**
     * Specifies the weight for QoS hit ratio
     */
    qosHitRatio?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS hops
     */
    qosHops?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS kilobytes per second
     */
    qosKilobytesSecond?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS link capacity
     */
    qosLcs?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS packet rate
     */
    qosPacketRate?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS round trip time
     */
    qosRtt?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS topology
     */
    qosTopology?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS virtual server capacity
     */
    qosVsCapacity?: pulumi.Input<number | undefined>;
    /**
     * Specifies the weight for QoS virtual server score
     */
    qosVsScore?: pulumi.Input<number | undefined>;
    /**
     * Specifies the time to live (TTL) for the pool
     */
    ttl?: pulumi.Input<number | undefined>;
    /**
     * Type of GTM pool (a, aaaa, cname, mx, naptr, srv)
     */
    type: pulumi.Input<string>;
    /**
     * Specifies whether the system verifies the availability of pool members before sending traffic
     */
    verifyMemberAvailability?: pulumi.Input<string | undefined>;
}
//# sourceMappingURL=gtmPool.d.ts.map