import * as pulumi from "@pulumi/pulumi";
/**
 * ## # f5bigip.GtmWideip Resource
 *
 * Provides a BIG-IP GTM (Global Traffic Manager) WideIP resource. This resource allows you to configure and manage GTM WideIP objects on a BIG-IP system.
 *
 * ## Description
 *
 * A WideIP is a DNS name that GTM resolves on behalf of an authoritative DNS server. WideIPs are the core objects in GTM that enable intelligent DNS-based load balancing and failover across multiple data centers.
 *
 * GTM WideIP types correspond to different DNS record types:
 * - **a**: IPv4 address records
 * - **aaaa**: IPv6 address records
 * - **cname**: Canonical name records
 * - **mx**: Mail exchange records
 * - **naptr**: Naming authority pointer records
 * - **srv**: Service locator records
 *
 * ## Example Usage
 *
 * ### Basic WideIP
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const example = new f5bigip.GtmWideip("example", {
 *     name: "testwideip.local",
 *     type: "a",
 *     partition: "Common",
 *     description: "test_wideip_a",
 * });
 * ```
 *
 * ### WideIP with Last Resort Pool
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const withPool = new f5bigip.GtmWideip("with_pool", {
 *     name: "app.example.com",
 *     type: "a",
 *     partition: "Common",
 *     description: "Application WideIP",
 *     lastResortPool: "a /Common/firstpool",
 *     poolLbMode: "round-robin",
 *     minimalResponse: "enabled",
 * });
 * ```
 *
 * ### Advanced WideIP Configuration
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const advanced = new f5bigip.GtmWideip("advanced", {
 *     name: "advanced.example.com",
 *     type: "a",
 *     partition: "Common",
 *     description: "Advanced WideIP configuration",
 *     enabled: true,
 *     failureRcode: "servfail",
 *     failureRcodeResponse: "enabled",
 *     failureRcodeTtl: 300,
 *     lastResortPool: "a /Common/backup_pool",
 *     minimalResponse: "disabled",
 *     persistCidrIpv4: 24,
 *     persistCidrIpv6: 64,
 *     persistence: "enabled",
 *     poolLbMode: "topology",
 *     ttlPersistence: 7200,
 *     topologyPreferEdns0ClientSubnet: "enabled",
 *     loadBalancingDecisionLogVerbosities: [
 *         "pool-selection",
 *         "pool-member-selection",
 *     ],
 *     aliases: [
 *         "app1.example.com",
 *         "app2.example.com",
 *     ],
 * });
 * ```
 *
 * ### IPv6 WideIP
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const ipv6 = new f5bigip.GtmWideip("ipv6", {
 *     name: "ipv6.example.com",
 *     type: "aaaa",
 *     partition: "Common",
 *     description: "IPv6 WideIP",
 *     enabled: true,
 *     poolLbMode: "round-robin",
 * });
 * ```
 *
 * ## Notes
 *
 * ### Pool Load Balancing Modes
 *
 * The `poolLbMode` determines how GTM distributes DNS queries across pools:
 *
 * - **round-robin**: Distributes queries equally across all available pools
 * - **ratio**: Distributes queries based on pool ratios
 * - **topology**: Uses topology records to determine the best pool
 * - **global-availability**: Considers pool availability and load
 * - **virtual-server-capacity**: Based on virtual server capacity
 * - **least-connections**: Selects pool with fewest active connections
 * - **lowest-round-trip-time**: Selects pool with lowest RTT
 * - **fewest-hops**: Selects pool 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
 * - **drop-packet**: Drops DNS packets (used for testing)
 * - **fallback-ip**: Returns a fallback IP address
 * - **virtual-server-score**: Based on virtual server scores
 *
 * ### Last Resort Pool Format
 *
 * The `lastResortPool` must be specified in the format: `<type> <partition>/<pool_name>`
 *
 * Examples:
 * - `a /Common/firstpool` - IPv4 pool
 * - `aaaa /Common/ipv6pool` - IPv6 pool
 * - `cname /Prod/alias_pool` - CNAME pool
 *
 * ### Persistence
 *
 * When persistence is enabled:
 * - GTM maintains a mapping of client IP addresses to pool members
 * - Subsequent requests from the same client are directed to the same destination
 * - The `persistCidrIpv4` and `persistCidrIpv6` settings determine the subnet mask used for grouping client IPs
 * - Persistence records expire after `ttlPersistence` seconds
 *
 * ### Failure RCODE Response
 *
 * When a WideIP becomes unavailable (all pools are down):
 * - If `failureRcodeResponse` is `disabled`: GTM returns no answer (NXDOMAIN)
 * - If `failureRcodeResponse` is `enabled`: GTM returns the specified `failureRcode`
 *
 * Common RCODE values:
 * - **noerror**: No error (returns empty response)
 * - **servfail**: Server failure
 * - **nxdomain**: Non-existent domain
 * - **refused**: Query refused
 *
 * ### Aliases
 *
 * Aliases allow you to specify alternate domain names for the same WideIP configuration. When a DNS query is made for any of the aliases, it is handled by the same WideIP configuration.
 *
 * Example:
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const app = new f5bigip.GtmWideip("app", {
 *     name: "app.example.com",
 *     type: "a",
 *     aliases: [
 *         "app-alias1.example.com",
 *         "app-alias2.example.com",
 *         "app.backup.example.com",
 *     ],
 * });
 * ```
 *
 * In this example, DNS queries for `app.example.com`, `app-alias1.example.com`, `app-alias2.example.com`, or `app.backup.example.com` will all be handled by the same WideIP configuration.
 *
 * ## API Endpoints
 *
 * This resource interacts with the following BIG-IP API endpoints:
 *
 * - `GET /mgmt/tm/gtm/wideip/<type>/<name>` - Read WideIP configuration
 * - `POST /mgmt/tm/gtm/wideip/<type>` - Create WideIP
 * - `PUT /mgmt/tm/gtm/wideip/<type>/<name>` - Update WideIP configuration
 * - `DELETE /mgmt/tm/gtm/wideip/<type>/<name>` - Delete WideIP
 *
 * ## Related Resources
 *
 * - `f5bigip.GtmPool` - Manages GTM pools that can be referenced by WideIPs
 * - `f5bigip.GtmServer` - Manages GTM servers that contain virtual servers
 * - `f5bigip.GtmDatacenter` - Manages GTM data centers
 * - `bigipGtmTopology` - Manages topology records for topology-based load balancing
 *
 * ## Import
 *
 * GTM WideIP resources can be imported using the format `type:/partition/name`. For example:
 *
 * ```sh
 * $ pulumi import f5bigip:index/gtmWideip:GtmWideip example a:/Common/testwideip.local
 * ```
 *
 * Additional import examples:
 *
 * Import an IPv6 WideIP
 *
 * ```sh
 * $ pulumi import f5bigip:index/gtmWideip:GtmWideip ipv6_example aaaa:/Common/ipv6.example.com
 * ```
 *
 * Import a CNAME WideIP
 *
 * ```sh
 * $ pulumi import f5bigip:index/gtmWideip:GtmWideip cname_example cname:/Common/alias.example.com
 * ```
 *
 * Import from a non-Common partition
 *
 * ```sh
 * $ pulumi import f5bigip:index/gtmWideip:GtmWideip prod_example a:/Production/app.example.com
 * ```
 */
export declare class GtmWideip extends pulumi.CustomResource {
    /**
     * Get an existing GtmWideip 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?: GtmWideipState, opts?: pulumi.CustomResourceOptions): GtmWideip;
    /**
     * Returns true if the given object is an instance of GtmWideip.  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 GtmWideip;
    /**
     * Specifies alternate domain names for the WideIP
     */
    readonly aliases: pulumi.Output<string[] | undefined>;
    /**
     * User-defined description of the WideIP
     */
    readonly description: pulumi.Output<string | undefined>;
    /**
     * Disabled state of the WideIP
     */
    readonly disabled: pulumi.Output<boolean | undefined>;
    /**
     * Enable or disable the WideIP
     */
    readonly enabled: pulumi.Output<boolean | undefined>;
    /**
     * Specifies the DNS RCODE used when failureRcodeResponse is enabled (noerror, formerr, servfail, nxdomain, notimp, refused, yxdomain, yxrrset, nxrrset, notauth, notzone)
     */
    readonly failureRcode: pulumi.Output<string | undefined>;
    /**
     * Specifies whether to return a RCODE response to DNS queries when the WideIP is unavailable (enabled or disabled)
     */
    readonly failureRcodeResponse: pulumi.Output<string | undefined>;
    /**
     * Specifies the negative caching TTL of the SOA for the RCODE response
     */
    readonly failureRcodeTtl: pulumi.Output<number | undefined>;
    /**
     * Specifies the last resort pool for the WideIP. Format: <type> <partition>/<pool_name> (e.g., 'a /Common/firstpool')
     */
    readonly lastResortPool: pulumi.Output<string | undefined>;
    /**
     * Specifies the amount of detail logged when making load balancing decisions. Example: ['pool-selection']
     */
    readonly loadBalancingDecisionLogVerbosities: pulumi.Output<string[] | undefined>;
    /**
     * Specifies whether to minimize the response to the DNS query (enabled or disabled)
     */
    readonly minimalResponse: pulumi.Output<string | undefined>;
    /**
     * Name of the WideIP. Example: testwideip.local
     */
    readonly name: pulumi.Output<string>;
    /**
     * Partition in which the WideIP resides
     */
    readonly partition: pulumi.Output<string | undefined>;
    /**
     * Specifies the CIDR for IPv4 persistence
     */
    readonly persistCidrIpv4: pulumi.Output<number | undefined>;
    /**
     * Specifies the CIDR for IPv6 persistence
     */
    readonly persistCidrIpv6: pulumi.Output<number | undefined>;
    /**
     * Specifies persistence for the WideIP (disabled or enabled)
     */
    readonly persistence: pulumi.Output<string | undefined>;
    /**
     * Specifies the load balancing mode for pools in the WideIP (round-robin, ratio, topology, global-availability)
     */
    readonly poolLbMode: pulumi.Output<string | undefined>;
    /**
     * Specifies whether to prefer EDNS0 client subnet data for topology-based load balancing (enabled or disabled)
     */
    readonly topologyPreferEdns0ClientSubnet: pulumi.Output<string | undefined>;
    /**
     * Specifies the TTL for the persistence of the WideIP
     */
    readonly ttlPersistence: pulumi.Output<number | undefined>;
    /**
     * Specifies the type of WideIP (a, aaaa, cname, mx, naptr, srv)
     */
    readonly type: pulumi.Output<string>;
    /**
     * Create a GtmWideip 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: GtmWideipArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering GtmWideip resources.
 */
export interface GtmWideipState {
    /**
     * Specifies alternate domain names for the WideIP
     */
    aliases?: pulumi.Input<pulumi.Input<string>[] | undefined>;
    /**
     * User-defined description of the WideIP
     */
    description?: pulumi.Input<string | undefined>;
    /**
     * Disabled state of the WideIP
     */
    disabled?: pulumi.Input<boolean | undefined>;
    /**
     * Enable or disable the WideIP
     */
    enabled?: pulumi.Input<boolean | undefined>;
    /**
     * Specifies the DNS RCODE used when failureRcodeResponse is enabled (noerror, formerr, servfail, nxdomain, notimp, refused, yxdomain, yxrrset, nxrrset, notauth, notzone)
     */
    failureRcode?: pulumi.Input<string | undefined>;
    /**
     * Specifies whether to return a RCODE response to DNS queries when the WideIP is unavailable (enabled or disabled)
     */
    failureRcodeResponse?: pulumi.Input<string | undefined>;
    /**
     * Specifies the negative caching TTL of the SOA for the RCODE response
     */
    failureRcodeTtl?: pulumi.Input<number | undefined>;
    /**
     * Specifies the last resort pool for the WideIP. Format: <type> <partition>/<pool_name> (e.g., 'a /Common/firstpool')
     */
    lastResortPool?: pulumi.Input<string | undefined>;
    /**
     * Specifies the amount of detail logged when making load balancing decisions. Example: ['pool-selection']
     */
    loadBalancingDecisionLogVerbosities?: pulumi.Input<pulumi.Input<string>[] | undefined>;
    /**
     * Specifies whether to minimize the response to the DNS query (enabled or disabled)
     */
    minimalResponse?: pulumi.Input<string | undefined>;
    /**
     * Name of the WideIP. Example: testwideip.local
     */
    name?: pulumi.Input<string | undefined>;
    /**
     * Partition in which the WideIP resides
     */
    partition?: pulumi.Input<string | undefined>;
    /**
     * Specifies the CIDR for IPv4 persistence
     */
    persistCidrIpv4?: pulumi.Input<number | undefined>;
    /**
     * Specifies the CIDR for IPv6 persistence
     */
    persistCidrIpv6?: pulumi.Input<number | undefined>;
    /**
     * Specifies persistence for the WideIP (disabled or enabled)
     */
    persistence?: pulumi.Input<string | undefined>;
    /**
     * Specifies the load balancing mode for pools in the WideIP (round-robin, ratio, topology, global-availability)
     */
    poolLbMode?: pulumi.Input<string | undefined>;
    /**
     * Specifies whether to prefer EDNS0 client subnet data for topology-based load balancing (enabled or disabled)
     */
    topologyPreferEdns0ClientSubnet?: pulumi.Input<string | undefined>;
    /**
     * Specifies the TTL for the persistence of the WideIP
     */
    ttlPersistence?: pulumi.Input<number | undefined>;
    /**
     * Specifies the type of WideIP (a, aaaa, cname, mx, naptr, srv)
     */
    type?: pulumi.Input<string | undefined>;
}
/**
 * The set of arguments for constructing a GtmWideip resource.
 */
export interface GtmWideipArgs {
    /**
     * Specifies alternate domain names for the WideIP
     */
    aliases?: pulumi.Input<pulumi.Input<string>[] | undefined>;
    /**
     * User-defined description of the WideIP
     */
    description?: pulumi.Input<string | undefined>;
    /**
     * Disabled state of the WideIP
     */
    disabled?: pulumi.Input<boolean | undefined>;
    /**
     * Enable or disable the WideIP
     */
    enabled?: pulumi.Input<boolean | undefined>;
    /**
     * Specifies the DNS RCODE used when failureRcodeResponse is enabled (noerror, formerr, servfail, nxdomain, notimp, refused, yxdomain, yxrrset, nxrrset, notauth, notzone)
     */
    failureRcode?: pulumi.Input<string | undefined>;
    /**
     * Specifies whether to return a RCODE response to DNS queries when the WideIP is unavailable (enabled or disabled)
     */
    failureRcodeResponse?: pulumi.Input<string | undefined>;
    /**
     * Specifies the negative caching TTL of the SOA for the RCODE response
     */
    failureRcodeTtl?: pulumi.Input<number | undefined>;
    /**
     * Specifies the last resort pool for the WideIP. Format: <type> <partition>/<pool_name> (e.g., 'a /Common/firstpool')
     */
    lastResortPool?: pulumi.Input<string | undefined>;
    /**
     * Specifies the amount of detail logged when making load balancing decisions. Example: ['pool-selection']
     */
    loadBalancingDecisionLogVerbosities?: pulumi.Input<pulumi.Input<string>[] | undefined>;
    /**
     * Specifies whether to minimize the response to the DNS query (enabled or disabled)
     */
    minimalResponse?: pulumi.Input<string | undefined>;
    /**
     * Name of the WideIP. Example: testwideip.local
     */
    name: pulumi.Input<string>;
    /**
     * Partition in which the WideIP resides
     */
    partition?: pulumi.Input<string | undefined>;
    /**
     * Specifies the CIDR for IPv4 persistence
     */
    persistCidrIpv4?: pulumi.Input<number | undefined>;
    /**
     * Specifies the CIDR for IPv6 persistence
     */
    persistCidrIpv6?: pulumi.Input<number | undefined>;
    /**
     * Specifies persistence for the WideIP (disabled or enabled)
     */
    persistence?: pulumi.Input<string | undefined>;
    /**
     * Specifies the load balancing mode for pools in the WideIP (round-robin, ratio, topology, global-availability)
     */
    poolLbMode?: pulumi.Input<string | undefined>;
    /**
     * Specifies whether to prefer EDNS0 client subnet data for topology-based load balancing (enabled or disabled)
     */
    topologyPreferEdns0ClientSubnet?: pulumi.Input<string | undefined>;
    /**
     * Specifies the TTL for the persistence of the WideIP
     */
    ttlPersistence?: pulumi.Input<number | undefined>;
    /**
     * Specifies the type of WideIP (a, aaaa, cname, mx, naptr, srv)
     */
    type: pulumi.Input<string>;
}
//# sourceMappingURL=gtmWideip.d.ts.map