import * as pulumi from "@pulumi/pulumi";
import * as inputs from "./types/input";
import * as outputs from "./types/output";
/**
 * ## # f5bigip.GtmServer
 *
 * Manages F5 BIG-IP GTM (Global Traffic Manager) Server resources.
 *
 * A GTM server represents a BIG-IP system, a host, or a server that hosts applications. Servers are identified by their addresses and are organized within datacenters. GTM servers enable GTM to perform load balancing and provide health monitoring for distributed applications.
 *
 * ## Example Usage
 *
 * ### Basic GTM Server (BIG-IP)
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const dc1 = new f5bigip.GtmDatacenter("dc1", {name: "datacenter1"});
 * const server1 = new f5bigip.GtmServer("server1", {
 *     name: "bigip_server1",
 *     datacenter: dc1.name,
 *     product: "bigip",
 *     addresses: [{
 *         name: "10.1.1.1",
 *     }],
 *     monitor: "/Common/bigip",
 *     virtualServerDiscovery: "true",
 *     linkDiscovery: "disabled",
 * });
 * ```
 *
 * ### GTM Server with Multiple Addresses
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const dc1 = new f5bigip.GtmDatacenter("dc1", {name: "datacenter1"});
 * const multiAddressServer = new f5bigip.GtmServer("multi_address_server", {
 *     name: "multi_server",
 *     datacenter: dc1.name,
 *     product: "bigip",
 *     addresses: [
 *         {
 *             name: "10.1.1.1",
 *             deviceName: "/Common/bigip1.example.com",
 *             translation: "none",
 *         },
 *         {
 *             name: "10.1.1.2",
 *             deviceName: "/Common/bigip2.example.com",
 *             translation: "none",
 *         },
 *     ],
 *     monitor: "/Common/bigip",
 *     virtualServerDiscovery: "true",
 * });
 * ```
 *
 * ### GTM Server with Address Translation
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const dc1 = new f5bigip.GtmDatacenter("dc1", {name: "datacenter1"});
 * const natServer = new f5bigip.GtmServer("nat_server", {
 *     name: "nat_server",
 *     datacenter: dc1.name,
 *     product: "bigip",
 *     addresses: [{
 *         name: "10.10.10.10",
 *         deviceName: "/Common/server.example.com",
 *         translation: "192.168.1.10",
 *     }],
 *     monitor: "/Common/bigip",
 *     virtualServerDiscovery: "true",
 * });
 * ```
 *
 * ### Generic Host Server
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const dc1 = new f5bigip.GtmDatacenter("dc1", {name: "datacenter1"});
 * const genericHost = new f5bigip.GtmServer("generic_host", {
 *     name: "generic_server",
 *     datacenter: dc1.name,
 *     product: "generic-host",
 *     addresses: [{
 *         name: "10.20.20.20",
 *     }],
 *     monitor: "/Common/tcp",
 *     virtualServerDiscovery: "false",
 *     linkDiscovery: "disabled",
 * });
 * ```
 *
 * ### Generic Host Server with Virtual Servers
 *
 * For generic-host servers that don't support virtual server discovery, you can manually define virtual servers:
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const dc1 = new f5bigip.GtmDatacenter("dc1", {name: "datacenter1"});
 * const genericWithVs = new f5bigip.GtmServer("generic_with_vs", {
 *     name: "generic_app_server",
 *     datacenter: dc1.name,
 *     product: "generic-host",
 *     addresses: [{
 *         name: "192.168.10.100",
 *     }],
 *     virtualServerDiscovery: "disabled",
 *     linkDiscovery: "disabled",
 *     virtualServers: [
 *         {
 *             name: "vs_http",
 *             destination: "192.168.10.100:80",
 *             enabled: true,
 *         },
 *         {
 *             name: "vs_https",
 *             destination: "192.168.10.100:443",
 *             enabled: true,
 *         },
 *         {
 *             name: "vs_api",
 *             destination: "192.168.10.100:8080",
 *             enabled: true,
 *             translationAddress: "none",
 *             translationPort: 0,
 *         },
 *     ],
 *     enabled: true,
 * });
 * ```
 *
 * ### GTM Server with Prober Settings
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const dc1 = new f5bigip.GtmDatacenter("dc1", {name: "datacenter1"});
 * const proberServer = new f5bigip.GtmServer("prober_server", {
 *     name: "prober_configured_server",
 *     datacenter: dc1.name,
 *     product: "bigip",
 *     addresses: [{
 *         name: "10.30.30.30",
 *     }],
 *     monitor: "/Common/bigip",
 *     virtualServerDiscovery: "true",
 *     proberPreference: "inside-datacenter",
 *     proberFallback: "any-available",
 *     iqAllowPath: true,
 *     iqAllowServiceCheck: true,
 *     iqAllowSnmp: true,
 * });
 * ```
 *
 * ### GTM Server with Resource Limits
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as f5bigip from "@pulumi/f5bigip";
 *
 * const dc1 = new f5bigip.GtmDatacenter("dc1", {name: "datacenter1"});
 * const limitedServer = new f5bigip.GtmServer("limited_server", {
 *     name: "resource_limited_server",
 *     datacenter: dc1.name,
 *     product: "bigip",
 *     addresses: [{
 *         name: "10.40.40.40",
 *     }],
 *     monitor: "/Common/bigip",
 *     virtualServerDiscovery: "true",
 *     limitMaxConnections: 10000,
 *     limitMaxBps: 1000000,
 *     limitMaxPps: 50000,
 *     limitCpuUsage: 80,
 *     limitMemAvail: 1024,
 * });
 * ```
 *
 * ## Notes
 *
 * * When creating a GTM server of type `bigip`, ensure that the BIG-IP device is accessible and properly configured for GTM communication.
 *
 * * Virtual server discovery requires proper iQuery communication between GTM systems.
 *
 * * Address translation is useful when servers are behind NAT.
 *
 * * Multiple addresses can be specified for servers with multiple network interfaces or for redundancy.
 *
 * * Resource limits help prevent a single server from consuming all available capacity in load balancing decisions.
 *
 * * Prober settings control how GTM monitors server health from different network locations.
 *
 * ## Import
 *
 * GTM servers can be imported using the server name or full path:
 *
 * ```sh
 * $ pulumi import f5bigip:index/gtmServer:GtmServer example /Common/server1
 * ```
 *
 * or
 *
 * ```sh
 * $ pulumi import f5bigip:index/gtmServer:GtmServer example server1
 * ```
 */
export declare class GtmServer extends pulumi.CustomResource {
    /**
     * Get an existing GtmServer 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?: GtmServerState, opts?: pulumi.CustomResourceOptions): GtmServer;
    /**
     * Returns true if the given object is an instance of GtmServer.  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 GtmServer;
    /**
     * List of IP addresses for the server. Each address block supports:
     */
    readonly addresses: pulumi.Output<outputs.GtmServerAddress[] | undefined>;
    /**
     * The datacenter where this server resides. Must be a valid datacenter name or full path (e.g., `/Common/datacenter1`).
     */
    readonly datacenter: pulumi.Output<string>;
    /**
     * Description of the GTM server
     */
    readonly description: pulumi.Output<string | undefined>;
    /**
     * Enable or disable the GTM server
     */
    readonly enabled: pulumi.Output<boolean | undefined>;
    /**
     * Allow GTM server to expose route domains. Default is `false`.
     */
    readonly exposeRouteDomains: pulumi.Output<boolean | undefined>;
    /**
     * Enable iQuery path probing. Default is `true`.
     */
    readonly iqAllowPath: pulumi.Output<boolean | undefined>;
    /**
     * Enable iQuery service checking. Default is `true`.
     */
    readonly iqAllowServiceCheck: pulumi.Output<boolean | undefined>;
    /**
     * Enable iQuery SNMP. Default is `true`.
     */
    readonly iqAllowSnmp: pulumi.Output<boolean | undefined>;
    /**
     * Maximum CPU usage allowed (percent). 0 means no limit. Default is `0`.
     */
    readonly limitCpuUsage: pulumi.Output<number | undefined>;
    /**
     * CPU usage limit status.
     */
    readonly limitCpuUsageStatus: pulumi.Output<string>;
    /**
     * Maximum bits per second. 0 means no limit. Default is `0`.
     */
    readonly limitMaxBps: pulumi.Output<number | undefined>;
    /**
     * Maximum bps limit status.
     */
    readonly limitMaxBpsStatus: pulumi.Output<string>;
    /**
     * Maximum concurrent connections. 0 means no limit. Default is `0`.
     */
    readonly limitMaxConnections: pulumi.Output<number | undefined>;
    /**
     * Maximum connections limit status.
     */
    readonly limitMaxConnectionsStatus: pulumi.Output<string>;
    /**
     * Maximum packets per second. 0 means no limit. Default is `0`.
     */
    readonly limitMaxPps: pulumi.Output<number | undefined>;
    /**
     * Maximum pps limit status.
     */
    readonly limitMaxPpsStatus: pulumi.Output<string>;
    /**
     * Available memory limit (MB). 0 means no limit. Default is `0`.
     */
    readonly limitMemAvail: pulumi.Output<number | undefined>;
    /**
     * Available memory limit status.
     */
    readonly limitMemAvailStatus: pulumi.Output<string>;
    /**
     * Link discovery mode. Valid values:
     */
    readonly linkDiscovery: pulumi.Output<string | undefined>;
    /**
     * Monitor assigned to check server health (e.g., `/Common/bigip`, `/Common/tcp`).
     */
    readonly monitor: pulumi.Output<string>;
    /**
     * Name of the GTM server. Must be unique within the partition.
     */
    readonly name: pulumi.Output<string>;
    /**
     * Partition or tenant the server belongs to. Default is `Common`.
     */
    readonly partition: pulumi.Output<string | undefined>;
    /**
     * Fallback prober selection. Valid values:
     */
    readonly proberFallback: pulumi.Output<string | undefined>;
    /**
     * Prober pool to use when proberPreference or proberFallback is set to pool
     */
    readonly proberPool: pulumi.Output<string | undefined>;
    /**
     * Preferred type of prober. Valid values:
     */
    readonly proberPreference: pulumi.Output<string | undefined>;
    /**
     * Type of server. Valid values are:
     */
    readonly product: pulumi.Output<string | undefined>;
    /**
     * Enable or disable virtual server discovery. Default is `true`. When enabled, GTM automatically discovers virtual servers on BIG-IP systems.
     */
    readonly virtualServerDiscovery: pulumi.Output<string | undefined>;
    /**
     * List of virtual servers for the GTM server. This is particularly useful for generic-host servers where virtual server discovery is not available. Each virtualServers block supports:
     */
    readonly virtualServers: pulumi.Output<outputs.GtmServerVirtualServer[] | undefined>;
    /**
     * Create a GtmServer 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: GtmServerArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering GtmServer resources.
 */
export interface GtmServerState {
    /**
     * List of IP addresses for the server. Each address block supports:
     */
    addresses?: pulumi.Input<pulumi.Input<inputs.GtmServerAddress>[] | undefined>;
    /**
     * The datacenter where this server resides. Must be a valid datacenter name or full path (e.g., `/Common/datacenter1`).
     */
    datacenter?: pulumi.Input<string | undefined>;
    /**
     * Description of the GTM server
     */
    description?: pulumi.Input<string | undefined>;
    /**
     * Enable or disable the GTM server
     */
    enabled?: pulumi.Input<boolean | undefined>;
    /**
     * Allow GTM server to expose route domains. Default is `false`.
     */
    exposeRouteDomains?: pulumi.Input<boolean | undefined>;
    /**
     * Enable iQuery path probing. Default is `true`.
     */
    iqAllowPath?: pulumi.Input<boolean | undefined>;
    /**
     * Enable iQuery service checking. Default is `true`.
     */
    iqAllowServiceCheck?: pulumi.Input<boolean | undefined>;
    /**
     * Enable iQuery SNMP. Default is `true`.
     */
    iqAllowSnmp?: pulumi.Input<boolean | undefined>;
    /**
     * Maximum CPU usage allowed (percent). 0 means no limit. Default is `0`.
     */
    limitCpuUsage?: pulumi.Input<number | undefined>;
    /**
     * CPU usage limit status.
     */
    limitCpuUsageStatus?: pulumi.Input<string | undefined>;
    /**
     * Maximum bits per second. 0 means no limit. Default is `0`.
     */
    limitMaxBps?: pulumi.Input<number | undefined>;
    /**
     * Maximum bps limit status.
     */
    limitMaxBpsStatus?: pulumi.Input<string | undefined>;
    /**
     * Maximum concurrent connections. 0 means no limit. Default is `0`.
     */
    limitMaxConnections?: pulumi.Input<number | undefined>;
    /**
     * Maximum connections limit status.
     */
    limitMaxConnectionsStatus?: pulumi.Input<string | undefined>;
    /**
     * Maximum packets per second. 0 means no limit. Default is `0`.
     */
    limitMaxPps?: pulumi.Input<number | undefined>;
    /**
     * Maximum pps limit status.
     */
    limitMaxPpsStatus?: pulumi.Input<string | undefined>;
    /**
     * Available memory limit (MB). 0 means no limit. Default is `0`.
     */
    limitMemAvail?: pulumi.Input<number | undefined>;
    /**
     * Available memory limit status.
     */
    limitMemAvailStatus?: pulumi.Input<string | undefined>;
    /**
     * Link discovery mode. Valid values:
     */
    linkDiscovery?: pulumi.Input<string | undefined>;
    /**
     * Monitor assigned to check server health (e.g., `/Common/bigip`, `/Common/tcp`).
     */
    monitor?: pulumi.Input<string | undefined>;
    /**
     * Name of the GTM server. Must be unique within the partition.
     */
    name?: pulumi.Input<string | undefined>;
    /**
     * Partition or tenant the server belongs to. Default is `Common`.
     */
    partition?: pulumi.Input<string | undefined>;
    /**
     * Fallback prober selection. Valid values:
     */
    proberFallback?: pulumi.Input<string | undefined>;
    /**
     * Prober pool to use when proberPreference or proberFallback is set to pool
     */
    proberPool?: pulumi.Input<string | undefined>;
    /**
     * Preferred type of prober. Valid values:
     */
    proberPreference?: pulumi.Input<string | undefined>;
    /**
     * Type of server. Valid values are:
     */
    product?: pulumi.Input<string | undefined>;
    /**
     * Enable or disable virtual server discovery. Default is `true`. When enabled, GTM automatically discovers virtual servers on BIG-IP systems.
     */
    virtualServerDiscovery?: pulumi.Input<string | undefined>;
    /**
     * List of virtual servers for the GTM server. This is particularly useful for generic-host servers where virtual server discovery is not available. Each virtualServers block supports:
     */
    virtualServers?: pulumi.Input<pulumi.Input<inputs.GtmServerVirtualServer>[] | undefined>;
}
/**
 * The set of arguments for constructing a GtmServer resource.
 */
export interface GtmServerArgs {
    /**
     * List of IP addresses for the server. Each address block supports:
     */
    addresses?: pulumi.Input<pulumi.Input<inputs.GtmServerAddress>[] | undefined>;
    /**
     * The datacenter where this server resides. Must be a valid datacenter name or full path (e.g., `/Common/datacenter1`).
     */
    datacenter: pulumi.Input<string>;
    /**
     * Description of the GTM server
     */
    description?: pulumi.Input<string | undefined>;
    /**
     * Enable or disable the GTM server
     */
    enabled?: pulumi.Input<boolean | undefined>;
    /**
     * Allow GTM server to expose route domains. Default is `false`.
     */
    exposeRouteDomains?: pulumi.Input<boolean | undefined>;
    /**
     * Enable iQuery path probing. Default is `true`.
     */
    iqAllowPath?: pulumi.Input<boolean | undefined>;
    /**
     * Enable iQuery service checking. Default is `true`.
     */
    iqAllowServiceCheck?: pulumi.Input<boolean | undefined>;
    /**
     * Enable iQuery SNMP. Default is `true`.
     */
    iqAllowSnmp?: pulumi.Input<boolean | undefined>;
    /**
     * Maximum CPU usage allowed (percent). 0 means no limit. Default is `0`.
     */
    limitCpuUsage?: pulumi.Input<number | undefined>;
    /**
     * CPU usage limit status.
     */
    limitCpuUsageStatus?: pulumi.Input<string | undefined>;
    /**
     * Maximum bits per second. 0 means no limit. Default is `0`.
     */
    limitMaxBps?: pulumi.Input<number | undefined>;
    /**
     * Maximum bps limit status.
     */
    limitMaxBpsStatus?: pulumi.Input<string | undefined>;
    /**
     * Maximum concurrent connections. 0 means no limit. Default is `0`.
     */
    limitMaxConnections?: pulumi.Input<number | undefined>;
    /**
     * Maximum connections limit status.
     */
    limitMaxConnectionsStatus?: pulumi.Input<string | undefined>;
    /**
     * Maximum packets per second. 0 means no limit. Default is `0`.
     */
    limitMaxPps?: pulumi.Input<number | undefined>;
    /**
     * Maximum pps limit status.
     */
    limitMaxPpsStatus?: pulumi.Input<string | undefined>;
    /**
     * Available memory limit (MB). 0 means no limit. Default is `0`.
     */
    limitMemAvail?: pulumi.Input<number | undefined>;
    /**
     * Available memory limit status.
     */
    limitMemAvailStatus?: pulumi.Input<string | undefined>;
    /**
     * Link discovery mode. Valid values:
     */
    linkDiscovery?: pulumi.Input<string | undefined>;
    /**
     * Monitor assigned to check server health (e.g., `/Common/bigip`, `/Common/tcp`).
     */
    monitor?: pulumi.Input<string | undefined>;
    /**
     * Name of the GTM server. Must be unique within the partition.
     */
    name: pulumi.Input<string>;
    /**
     * Partition or tenant the server belongs to. Default is `Common`.
     */
    partition?: pulumi.Input<string | undefined>;
    /**
     * Fallback prober selection. Valid values:
     */
    proberFallback?: pulumi.Input<string | undefined>;
    /**
     * Prober pool to use when proberPreference or proberFallback is set to pool
     */
    proberPool?: pulumi.Input<string | undefined>;
    /**
     * Preferred type of prober. Valid values:
     */
    proberPreference?: pulumi.Input<string | undefined>;
    /**
     * Type of server. Valid values are:
     */
    product?: pulumi.Input<string | undefined>;
    /**
     * Enable or disable virtual server discovery. Default is `true`. When enabled, GTM automatically discovers virtual servers on BIG-IP systems.
     */
    virtualServerDiscovery?: pulumi.Input<string | undefined>;
    /**
     * List of virtual servers for the GTM server. This is particularly useful for generic-host servers where virtual server discovery is not available. Each virtualServers block supports:
     */
    virtualServers?: pulumi.Input<pulumi.Input<inputs.GtmServerVirtualServer>[] | undefined>;
}
//# sourceMappingURL=gtmServer.d.ts.map