import * as Core from 'cloudflare/core';
import { APIResource } from 'cloudflare/resource';
import * as PoolsAPI from 'cloudflare/resources/user/load-balancers/pools';
import { SinglePage } from 'cloudflare/pagination';
export declare class Pools extends APIResource {
    /**
     * Create a new pool.
     */
    create(body: PoolCreateParams, options?: Core.RequestOptions): Core.APIPromise<LoadBalancingPool>;
    /**
     * Modify a configured pool.
     */
    update(poolId: string, body: PoolUpdateParams, options?: Core.RequestOptions): Core.APIPromise<LoadBalancingPool>;
    /**
     * List configured pools.
     */
    list(query?: PoolListParams, options?: Core.RequestOptions): Core.PagePromise<LoadBalancingPoolsSinglePage, LoadBalancingPool>;
    list(options?: Core.RequestOptions): Core.PagePromise<LoadBalancingPoolsSinglePage, LoadBalancingPool>;
    /**
     * Delete a configured pool.
     */
    delete(poolId: string, options?: Core.RequestOptions): Core.APIPromise<PoolDeleteResponse>;
    /**
     * Apply changes to an existing pool, overwriting the supplied properties.
     */
    edit(poolId: string, body: PoolEditParams, options?: Core.RequestOptions): Core.APIPromise<LoadBalancingPool>;
    /**
     * Fetch a single configured pool.
     */
    get(poolId: string, options?: Core.RequestOptions): Core.APIPromise<LoadBalancingPool>;
    /**
     * Fetch the latest pool health status for a single pool.
     */
    health(poolId: string, options?: Core.RequestOptions): Core.APIPromise<PoolHealthResponse>;
    /**
     * Preview pool health using provided monitor details. The returned preview_id can
     * be used in the preview endpoint to retrieve the results.
     */
    preview(poolId: string, body: PoolPreviewParams, options?: Core.RequestOptions): Core.APIPromise<PoolPreviewResponse>;
    /**
     * Get the list of resources that reference the provided pool.
     */
    references(poolId: string, options?: Core.RequestOptions): Core.APIPromise<PoolReferencesResponse | null>;
}
export declare class LoadBalancingPoolsSinglePage extends SinglePage<LoadBalancingPool> {
}
export interface LoadBalancingPool {
    id?: string;
    /**
     * A list of regions from which to run health checks. Null means every Cloudflare
     * data center.
     */
    check_regions?: Array<'WNAM' | 'ENAM' | 'WEU' | 'EEU' | 'NSAM' | 'SSAM' | 'OC' | 'ME' | 'NAF' | 'SAF' | 'SAS' | 'SEAS' | 'NEAS' | 'ALL_REGIONS'> | null;
    created_on?: string;
    /**
     * A human-readable description of the pool.
     */
    description?: string;
    /**
     * This field shows up only if the pool is disabled. This field is set with the
     * time the pool was disabled at.
     */
    disabled_at?: string;
    /**
     * Whether to enable (the default) or disable this pool. Disabled pools will not
     * receive traffic and are excluded from health checks. Disabling a pool will cause
     * any load balancers using it to failover to the next pool (if any).
     */
    enabled?: boolean;
    /**
     * The latitude of the data center containing the origins used in this pool in
     * decimal degrees. If this is set, longitude must also be set.
     */
    latitude?: number;
    /**
     * Configures load shedding policies and percentages for the pool.
     */
    load_shedding?: LoadBalancingPool.LoadShedding;
    /**
     * The longitude of the data center containing the origins used in this pool in
     * decimal degrees. If this is set, latitude must also be set.
     */
    longitude?: number;
    /**
     * The minimum number of origins that must be healthy for this pool to serve
     * traffic. If the number of healthy origins falls below this number, the pool will
     * be marked unhealthy and will failover to the next available pool.
     */
    minimum_origins?: number;
    modified_on?: string;
    /**
     * The ID of the Monitor to use for checking the health of origins within this
     * pool.
     */
    monitor?: unknown;
    /**
     * A short name (tag) for the pool. Only alphanumeric characters, hyphens, and
     * underscores are allowed.
     */
    name?: string;
    /**
     * This field is now deprecated. It has been moved to Cloudflare's Centralized
     * Notification service
     * https://developers.cloudflare.com/fundamentals/notifications/. The email address
     * to send health status notifications to. This can be an individual mailbox or a
     * mailing list. Multiple emails can be supplied as a comma delimited list.
     */
    notification_email?: string;
    /**
     * Filter pool and origin health notifications by resource type or health status.
     * Use null to reset.
     */
    notification_filter?: LoadBalancingPool.NotificationFilter | null;
    /**
     * Configures origin steering for the pool. Controls how origins are selected for
     * new sessions and traffic without session affinity.
     */
    origin_steering?: LoadBalancingPool.OriginSteering;
    /**
     * The list of origins within this pool. Traffic directed at this pool is balanced
     * across all currently healthy origins, provided the pool itself is healthy.
     */
    origins?: Array<LoadBalancingPool.Origin>;
}
export declare namespace LoadBalancingPool {
    /**
     * Configures load shedding policies and percentages for the pool.
     */
    interface LoadShedding {
        /**
         * The percent of traffic to shed from the pool, according to the default policy.
         * Applies to new sessions and traffic without session affinity.
         */
        default_percent?: number;
        /**
         * The default policy to use when load shedding. A random policy randomly sheds a
         * given percent of requests. A hash policy computes a hash over the
         * CF-Connecting-IP address and sheds all requests originating from a percent of
         * IPs.
         */
        default_policy?: 'random' | 'hash';
        /**
         * The percent of existing sessions to shed from the pool, according to the session
         * policy.
         */
        session_percent?: number;
        /**
         * Only the hash policy is supported for existing sessions (to avoid exponential
         * decay).
         */
        session_policy?: 'hash';
    }
    /**
     * Filter pool and origin health notifications by resource type or health status.
     * Use null to reset.
     */
    interface NotificationFilter {
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        origin?: NotificationFilter.Origin | null;
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        pool?: NotificationFilter.Pool | null;
    }
    namespace NotificationFilter {
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        interface Origin {
            /**
             * If set true, disable notifications for this type of resource (pool or origin).
             */
            disable?: boolean;
            /**
             * If present, send notifications only for this health status (e.g. false for only
             * DOWN events). Use null to reset (all events).
             */
            healthy?: boolean | null;
        }
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        interface Pool {
            /**
             * If set true, disable notifications for this type of resource (pool or origin).
             */
            disable?: boolean;
            /**
             * If present, send notifications only for this health status (e.g. false for only
             * DOWN events). Use null to reset (all events).
             */
            healthy?: boolean | null;
        }
    }
    /**
     * Configures origin steering for the pool. Controls how origins are selected for
     * new sessions and traffic without session affinity.
     */
    interface OriginSteering {
        /**
         * The type of origin steering policy to use.
         *
         * - `"random"`: Select an origin randomly.
         * - `"hash"`: Select an origin by computing a hash over the CF-Connecting-IP
         *   address.
         * - `"least_outstanding_requests"`: Select an origin by taking into consideration
         *   origin weights, as well as each origin's number of outstanding requests.
         *   Origins with more pending requests are weighted proportionately less relative
         *   to others.
         * - `"least_connections"`: Select an origin by taking into consideration origin
         *   weights, as well as each origin's number of open connections. Origins with
         *   more open connections are weighted proportionately less relative to others.
         *   Supported for HTTP/1 and HTTP/2 connections.
         */
        policy?: 'random' | 'hash' | 'least_outstanding_requests' | 'least_connections';
    }
    interface Origin {
        /**
         * The IP address (IPv4 or IPv6) of the origin, or its publicly addressable
         * hostname. Hostnames entered here should resolve directly to the origin, and not
         * be a hostname proxied by Cloudflare. To set an internal/reserved address,
         * virtual_network_id must also be set.
         */
        address?: string;
        /**
         * This field shows up only if the origin is disabled. This field is set with the
         * time the origin was disabled.
         */
        disabled_at?: string;
        /**
         * Whether to enable (the default) this origin within the pool. Disabled origins
         * will not receive traffic and are excluded from health checks. The origin will
         * only be disabled for the current pool.
         */
        enabled?: boolean;
        /**
         * The request header is used to pass additional information with an HTTP request.
         * Currently supported header is 'Host'.
         */
        header?: Origin.Header;
        /**
         * A human-identifiable name for the origin.
         */
        name?: string;
        /**
         * The virtual network subnet ID the origin belongs in. Virtual network must also
         * belong to the account.
         */
        virtual_network_id?: string;
        /**
         * The weight of this origin relative to other origins in the pool. Based on the
         * configured weight the total traffic is distributed among origins within the
         * pool.
         *
         * - `origin_steering.policy="least_outstanding_requests"`: Use weight to scale the
         *   origin's outstanding requests.
         * - `origin_steering.policy="least_connections"`: Use weight to scale the origin's
         *   open connections.
         */
        weight?: number;
    }
    namespace Origin {
        /**
         * The request header is used to pass additional information with an HTTP request.
         * Currently supported header is 'Host'.
         */
        interface Header {
            /**
             * The 'Host' header allows to override the hostname set in the HTTP request.
             * Current support is 1 'Host' header override per origin.
             */
            Host?: Array<string>;
        }
    }
}
export interface PoolDeleteResponse {
    id?: string;
}
/**
 * A list of regions from which to run health checks. Null means every Cloudflare
 * data center.
 */
export type PoolHealthResponse = unknown | string | null;
export interface PoolPreviewResponse {
    /**
     * Monitored pool IDs mapped to their respective names.
     */
    pools?: Record<string, string>;
    preview_id?: string;
}
/**
 * List of resources that reference a given pool.
 */
export type PoolReferencesResponse = Array<PoolReferencesResponse.PoolReferencesResponseItem>;
export declare namespace PoolReferencesResponse {
    interface PoolReferencesResponseItem {
        reference_type?: '*' | 'referral' | 'referrer';
        resource_id?: string;
        resource_name?: string;
        resource_type?: string;
    }
}
export interface PoolCreateParams {
    /**
     * A short name (tag) for the pool. Only alphanumeric characters, hyphens, and
     * underscores are allowed.
     */
    name: string;
    /**
     * The list of origins within this pool. Traffic directed at this pool is balanced
     * across all currently healthy origins, provided the pool itself is healthy.
     */
    origins: Array<PoolCreateParams.Origin>;
    /**
     * A list of regions from which to run health checks. Null means every Cloudflare
     * data center.
     */
    check_regions?: Array<'WNAM' | 'ENAM' | 'WEU' | 'EEU' | 'NSAM' | 'SSAM' | 'OC' | 'ME' | 'NAF' | 'SAF' | 'SAS' | 'SEAS' | 'NEAS' | 'ALL_REGIONS'> | null;
    /**
     * A human-readable description of the pool.
     */
    description?: string;
    /**
     * Whether to enable (the default) or disable this pool. Disabled pools will not
     * receive traffic and are excluded from health checks. Disabling a pool will cause
     * any load balancers using it to failover to the next pool (if any).
     */
    enabled?: boolean;
    /**
     * The latitude of the data center containing the origins used in this pool in
     * decimal degrees. If this is set, longitude must also be set.
     */
    latitude?: number;
    /**
     * Configures load shedding policies and percentages for the pool.
     */
    load_shedding?: PoolCreateParams.LoadShedding;
    /**
     * The longitude of the data center containing the origins used in this pool in
     * decimal degrees. If this is set, latitude must also be set.
     */
    longitude?: number;
    /**
     * The minimum number of origins that must be healthy for this pool to serve
     * traffic. If the number of healthy origins falls below this number, the pool will
     * be marked unhealthy and will failover to the next available pool.
     */
    minimum_origins?: number;
    /**
     * The ID of the Monitor to use for checking the health of origins within this
     * pool.
     */
    monitor?: unknown;
    /**
     * This field is now deprecated. It has been moved to Cloudflare's Centralized
     * Notification service
     * https://developers.cloudflare.com/fundamentals/notifications/. The email address
     * to send health status notifications to. This can be an individual mailbox or a
     * mailing list. Multiple emails can be supplied as a comma delimited list.
     */
    notification_email?: string;
    /**
     * Filter pool and origin health notifications by resource type or health status.
     * Use null to reset.
     */
    notification_filter?: PoolCreateParams.NotificationFilter | null;
    /**
     * Configures origin steering for the pool. Controls how origins are selected for
     * new sessions and traffic without session affinity.
     */
    origin_steering?: PoolCreateParams.OriginSteering;
}
export declare namespace PoolCreateParams {
    interface Origin {
        /**
         * The IP address (IPv4 or IPv6) of the origin, or its publicly addressable
         * hostname. Hostnames entered here should resolve directly to the origin, and not
         * be a hostname proxied by Cloudflare. To set an internal/reserved address,
         * virtual_network_id must also be set.
         */
        address?: string;
        /**
         * Whether to enable (the default) this origin within the pool. Disabled origins
         * will not receive traffic and are excluded from health checks. The origin will
         * only be disabled for the current pool.
         */
        enabled?: boolean;
        /**
         * The request header is used to pass additional information with an HTTP request.
         * Currently supported header is 'Host'.
         */
        header?: Origin.Header;
        /**
         * A human-identifiable name for the origin.
         */
        name?: string;
        /**
         * The virtual network subnet ID the origin belongs in. Virtual network must also
         * belong to the account.
         */
        virtual_network_id?: string;
        /**
         * The weight of this origin relative to other origins in the pool. Based on the
         * configured weight the total traffic is distributed among origins within the
         * pool.
         *
         * - `origin_steering.policy="least_outstanding_requests"`: Use weight to scale the
         *   origin's outstanding requests.
         * - `origin_steering.policy="least_connections"`: Use weight to scale the origin's
         *   open connections.
         */
        weight?: number;
    }
    namespace Origin {
        /**
         * The request header is used to pass additional information with an HTTP request.
         * Currently supported header is 'Host'.
         */
        interface Header {
            /**
             * The 'Host' header allows to override the hostname set in the HTTP request.
             * Current support is 1 'Host' header override per origin.
             */
            Host?: Array<string>;
        }
    }
    /**
     * Configures load shedding policies and percentages for the pool.
     */
    interface LoadShedding {
        /**
         * The percent of traffic to shed from the pool, according to the default policy.
         * Applies to new sessions and traffic without session affinity.
         */
        default_percent?: number;
        /**
         * The default policy to use when load shedding. A random policy randomly sheds a
         * given percent of requests. A hash policy computes a hash over the
         * CF-Connecting-IP address and sheds all requests originating from a percent of
         * IPs.
         */
        default_policy?: 'random' | 'hash';
        /**
         * The percent of existing sessions to shed from the pool, according to the session
         * policy.
         */
        session_percent?: number;
        /**
         * Only the hash policy is supported for existing sessions (to avoid exponential
         * decay).
         */
        session_policy?: 'hash';
    }
    /**
     * Filter pool and origin health notifications by resource type or health status.
     * Use null to reset.
     */
    interface NotificationFilter {
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        origin?: NotificationFilter.Origin | null;
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        pool?: NotificationFilter.Pool | null;
    }
    namespace NotificationFilter {
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        interface Origin {
            /**
             * If set true, disable notifications for this type of resource (pool or origin).
             */
            disable?: boolean;
            /**
             * If present, send notifications only for this health status (e.g. false for only
             * DOWN events). Use null to reset (all events).
             */
            healthy?: boolean | null;
        }
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        interface Pool {
            /**
             * If set true, disable notifications for this type of resource (pool or origin).
             */
            disable?: boolean;
            /**
             * If present, send notifications only for this health status (e.g. false for only
             * DOWN events). Use null to reset (all events).
             */
            healthy?: boolean | null;
        }
    }
    /**
     * Configures origin steering for the pool. Controls how origins are selected for
     * new sessions and traffic without session affinity.
     */
    interface OriginSteering {
        /**
         * The type of origin steering policy to use.
         *
         * - `"random"`: Select an origin randomly.
         * - `"hash"`: Select an origin by computing a hash over the CF-Connecting-IP
         *   address.
         * - `"least_outstanding_requests"`: Select an origin by taking into consideration
         *   origin weights, as well as each origin's number of outstanding requests.
         *   Origins with more pending requests are weighted proportionately less relative
         *   to others.
         * - `"least_connections"`: Select an origin by taking into consideration origin
         *   weights, as well as each origin's number of open connections. Origins with
         *   more open connections are weighted proportionately less relative to others.
         *   Supported for HTTP/1 and HTTP/2 connections.
         */
        policy?: 'random' | 'hash' | 'least_outstanding_requests' | 'least_connections';
    }
}
export interface PoolUpdateParams {
    /**
     * A short name (tag) for the pool. Only alphanumeric characters, hyphens, and
     * underscores are allowed.
     */
    name: string;
    /**
     * The list of origins within this pool. Traffic directed at this pool is balanced
     * across all currently healthy origins, provided the pool itself is healthy.
     */
    origins: Array<PoolUpdateParams.Origin>;
    /**
     * A list of regions from which to run health checks. Null means every Cloudflare
     * data center.
     */
    check_regions?: Array<'WNAM' | 'ENAM' | 'WEU' | 'EEU' | 'NSAM' | 'SSAM' | 'OC' | 'ME' | 'NAF' | 'SAF' | 'SAS' | 'SEAS' | 'NEAS' | 'ALL_REGIONS'> | null;
    /**
     * A human-readable description of the pool.
     */
    description?: string;
    /**
     * Whether to enable (the default) or disable this pool. Disabled pools will not
     * receive traffic and are excluded from health checks. Disabling a pool will cause
     * any load balancers using it to failover to the next pool (if any).
     */
    enabled?: boolean;
    /**
     * The latitude of the data center containing the origins used in this pool in
     * decimal degrees. If this is set, longitude must also be set.
     */
    latitude?: number;
    /**
     * Configures load shedding policies and percentages for the pool.
     */
    load_shedding?: PoolUpdateParams.LoadShedding;
    /**
     * The longitude of the data center containing the origins used in this pool in
     * decimal degrees. If this is set, latitude must also be set.
     */
    longitude?: number;
    /**
     * The minimum number of origins that must be healthy for this pool to serve
     * traffic. If the number of healthy origins falls below this number, the pool will
     * be marked unhealthy and will failover to the next available pool.
     */
    minimum_origins?: number;
    /**
     * The ID of the Monitor to use for checking the health of origins within this
     * pool.
     */
    monitor?: unknown;
    /**
     * This field is now deprecated. It has been moved to Cloudflare's Centralized
     * Notification service
     * https://developers.cloudflare.com/fundamentals/notifications/. The email address
     * to send health status notifications to. This can be an individual mailbox or a
     * mailing list. Multiple emails can be supplied as a comma delimited list.
     */
    notification_email?: string;
    /**
     * Filter pool and origin health notifications by resource type or health status.
     * Use null to reset.
     */
    notification_filter?: PoolUpdateParams.NotificationFilter | null;
    /**
     * Configures origin steering for the pool. Controls how origins are selected for
     * new sessions and traffic without session affinity.
     */
    origin_steering?: PoolUpdateParams.OriginSteering;
}
export declare namespace PoolUpdateParams {
    interface Origin {
        /**
         * The IP address (IPv4 or IPv6) of the origin, or its publicly addressable
         * hostname. Hostnames entered here should resolve directly to the origin, and not
         * be a hostname proxied by Cloudflare. To set an internal/reserved address,
         * virtual_network_id must also be set.
         */
        address?: string;
        /**
         * Whether to enable (the default) this origin within the pool. Disabled origins
         * will not receive traffic and are excluded from health checks. The origin will
         * only be disabled for the current pool.
         */
        enabled?: boolean;
        /**
         * The request header is used to pass additional information with an HTTP request.
         * Currently supported header is 'Host'.
         */
        header?: Origin.Header;
        /**
         * A human-identifiable name for the origin.
         */
        name?: string;
        /**
         * The virtual network subnet ID the origin belongs in. Virtual network must also
         * belong to the account.
         */
        virtual_network_id?: string;
        /**
         * The weight of this origin relative to other origins in the pool. Based on the
         * configured weight the total traffic is distributed among origins within the
         * pool.
         *
         * - `origin_steering.policy="least_outstanding_requests"`: Use weight to scale the
         *   origin's outstanding requests.
         * - `origin_steering.policy="least_connections"`: Use weight to scale the origin's
         *   open connections.
         */
        weight?: number;
    }
    namespace Origin {
        /**
         * The request header is used to pass additional information with an HTTP request.
         * Currently supported header is 'Host'.
         */
        interface Header {
            /**
             * The 'Host' header allows to override the hostname set in the HTTP request.
             * Current support is 1 'Host' header override per origin.
             */
            Host?: Array<string>;
        }
    }
    /**
     * Configures load shedding policies and percentages for the pool.
     */
    interface LoadShedding {
        /**
         * The percent of traffic to shed from the pool, according to the default policy.
         * Applies to new sessions and traffic without session affinity.
         */
        default_percent?: number;
        /**
         * The default policy to use when load shedding. A random policy randomly sheds a
         * given percent of requests. A hash policy computes a hash over the
         * CF-Connecting-IP address and sheds all requests originating from a percent of
         * IPs.
         */
        default_policy?: 'random' | 'hash';
        /**
         * The percent of existing sessions to shed from the pool, according to the session
         * policy.
         */
        session_percent?: number;
        /**
         * Only the hash policy is supported for existing sessions (to avoid exponential
         * decay).
         */
        session_policy?: 'hash';
    }
    /**
     * Filter pool and origin health notifications by resource type or health status.
     * Use null to reset.
     */
    interface NotificationFilter {
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        origin?: NotificationFilter.Origin | null;
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        pool?: NotificationFilter.Pool | null;
    }
    namespace NotificationFilter {
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        interface Origin {
            /**
             * If set true, disable notifications for this type of resource (pool or origin).
             */
            disable?: boolean;
            /**
             * If present, send notifications only for this health status (e.g. false for only
             * DOWN events). Use null to reset (all events).
             */
            healthy?: boolean | null;
        }
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        interface Pool {
            /**
             * If set true, disable notifications for this type of resource (pool or origin).
             */
            disable?: boolean;
            /**
             * If present, send notifications only for this health status (e.g. false for only
             * DOWN events). Use null to reset (all events).
             */
            healthy?: boolean | null;
        }
    }
    /**
     * Configures origin steering for the pool. Controls how origins are selected for
     * new sessions and traffic without session affinity.
     */
    interface OriginSteering {
        /**
         * The type of origin steering policy to use.
         *
         * - `"random"`: Select an origin randomly.
         * - `"hash"`: Select an origin by computing a hash over the CF-Connecting-IP
         *   address.
         * - `"least_outstanding_requests"`: Select an origin by taking into consideration
         *   origin weights, as well as each origin's number of outstanding requests.
         *   Origins with more pending requests are weighted proportionately less relative
         *   to others.
         * - `"least_connections"`: Select an origin by taking into consideration origin
         *   weights, as well as each origin's number of open connections. Origins with
         *   more open connections are weighted proportionately less relative to others.
         *   Supported for HTTP/1 and HTTP/2 connections.
         */
        policy?: 'random' | 'hash' | 'least_outstanding_requests' | 'least_connections';
    }
}
export interface PoolListParams {
    /**
     * The ID of the Monitor to use for checking the health of origins within this
     * pool.
     */
    monitor?: unknown;
}
export interface PoolEditParams {
    /**
     * A list of regions from which to run health checks. Null means every Cloudflare
     * data center.
     */
    check_regions?: Array<'WNAM' | 'ENAM' | 'WEU' | 'EEU' | 'NSAM' | 'SSAM' | 'OC' | 'ME' | 'NAF' | 'SAF' | 'SAS' | 'SEAS' | 'NEAS' | 'ALL_REGIONS'> | null;
    /**
     * A human-readable description of the pool.
     */
    description?: string;
    /**
     * Whether to enable (the default) or disable this pool. Disabled pools will not
     * receive traffic and are excluded from health checks. Disabling a pool will cause
     * any load balancers using it to failover to the next pool (if any).
     */
    enabled?: boolean;
    /**
     * The latitude of the data center containing the origins used in this pool in
     * decimal degrees. If this is set, longitude must also be set.
     */
    latitude?: number;
    /**
     * Configures load shedding policies and percentages for the pool.
     */
    load_shedding?: PoolEditParams.LoadShedding;
    /**
     * The longitude of the data center containing the origins used in this pool in
     * decimal degrees. If this is set, latitude must also be set.
     */
    longitude?: number;
    /**
     * The minimum number of origins that must be healthy for this pool to serve
     * traffic. If the number of healthy origins falls below this number, the pool will
     * be marked unhealthy and will failover to the next available pool.
     */
    minimum_origins?: number;
    /**
     * The ID of the Monitor to use for checking the health of origins within this
     * pool.
     */
    monitor?: unknown;
    /**
     * A short name (tag) for the pool. Only alphanumeric characters, hyphens, and
     * underscores are allowed.
     */
    name?: string;
    /**
     * This field is now deprecated. It has been moved to Cloudflare's Centralized
     * Notification service
     * https://developers.cloudflare.com/fundamentals/notifications/. The email address
     * to send health status notifications to. This can be an individual mailbox or a
     * mailing list. Multiple emails can be supplied as a comma delimited list.
     */
    notification_email?: string;
    /**
     * Filter pool and origin health notifications by resource type or health status.
     * Use null to reset.
     */
    notification_filter?: PoolEditParams.NotificationFilter | null;
    /**
     * Configures origin steering for the pool. Controls how origins are selected for
     * new sessions and traffic without session affinity.
     */
    origin_steering?: PoolEditParams.OriginSteering;
    /**
     * The list of origins within this pool. Traffic directed at this pool is balanced
     * across all currently healthy origins, provided the pool itself is healthy.
     */
    origins?: Array<PoolEditParams.Origin>;
}
export declare namespace PoolEditParams {
    /**
     * Configures load shedding policies and percentages for the pool.
     */
    interface LoadShedding {
        /**
         * The percent of traffic to shed from the pool, according to the default policy.
         * Applies to new sessions and traffic without session affinity.
         */
        default_percent?: number;
        /**
         * The default policy to use when load shedding. A random policy randomly sheds a
         * given percent of requests. A hash policy computes a hash over the
         * CF-Connecting-IP address and sheds all requests originating from a percent of
         * IPs.
         */
        default_policy?: 'random' | 'hash';
        /**
         * The percent of existing sessions to shed from the pool, according to the session
         * policy.
         */
        session_percent?: number;
        /**
         * Only the hash policy is supported for existing sessions (to avoid exponential
         * decay).
         */
        session_policy?: 'hash';
    }
    /**
     * Filter pool and origin health notifications by resource type or health status.
     * Use null to reset.
     */
    interface NotificationFilter {
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        origin?: NotificationFilter.Origin | null;
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        pool?: NotificationFilter.Pool | null;
    }
    namespace NotificationFilter {
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        interface Origin {
            /**
             * If set true, disable notifications for this type of resource (pool or origin).
             */
            disable?: boolean;
            /**
             * If present, send notifications only for this health status (e.g. false for only
             * DOWN events). Use null to reset (all events).
             */
            healthy?: boolean | null;
        }
        /**
         * Filter options for a particular resource type (pool or origin). Use null to
         * reset.
         */
        interface Pool {
            /**
             * If set true, disable notifications for this type of resource (pool or origin).
             */
            disable?: boolean;
            /**
             * If present, send notifications only for this health status (e.g. false for only
             * DOWN events). Use null to reset (all events).
             */
            healthy?: boolean | null;
        }
    }
    /**
     * Configures origin steering for the pool. Controls how origins are selected for
     * new sessions and traffic without session affinity.
     */
    interface OriginSteering {
        /**
         * The type of origin steering policy to use.
         *
         * - `"random"`: Select an origin randomly.
         * - `"hash"`: Select an origin by computing a hash over the CF-Connecting-IP
         *   address.
         * - `"least_outstanding_requests"`: Select an origin by taking into consideration
         *   origin weights, as well as each origin's number of outstanding requests.
         *   Origins with more pending requests are weighted proportionately less relative
         *   to others.
         * - `"least_connections"`: Select an origin by taking into consideration origin
         *   weights, as well as each origin's number of open connections. Origins with
         *   more open connections are weighted proportionately less relative to others.
         *   Supported for HTTP/1 and HTTP/2 connections.
         */
        policy?: 'random' | 'hash' | 'least_outstanding_requests' | 'least_connections';
    }
    interface Origin {
        /**
         * The IP address (IPv4 or IPv6) of the origin, or its publicly addressable
         * hostname. Hostnames entered here should resolve directly to the origin, and not
         * be a hostname proxied by Cloudflare. To set an internal/reserved address,
         * virtual_network_id must also be set.
         */
        address?: string;
        /**
         * Whether to enable (the default) this origin within the pool. Disabled origins
         * will not receive traffic and are excluded from health checks. The origin will
         * only be disabled for the current pool.
         */
        enabled?: boolean;
        /**
         * The request header is used to pass additional information with an HTTP request.
         * Currently supported header is 'Host'.
         */
        header?: Origin.Header;
        /**
         * A human-identifiable name for the origin.
         */
        name?: string;
        /**
         * The virtual network subnet ID the origin belongs in. Virtual network must also
         * belong to the account.
         */
        virtual_network_id?: string;
        /**
         * The weight of this origin relative to other origins in the pool. Based on the
         * configured weight the total traffic is distributed among origins within the
         * pool.
         *
         * - `origin_steering.policy="least_outstanding_requests"`: Use weight to scale the
         *   origin's outstanding requests.
         * - `origin_steering.policy="least_connections"`: Use weight to scale the origin's
         *   open connections.
         */
        weight?: number;
    }
    namespace Origin {
        /**
         * The request header is used to pass additional information with an HTTP request.
         * Currently supported header is 'Host'.
         */
        interface Header {
            /**
             * The 'Host' header allows to override the hostname set in the HTTP request.
             * Current support is 1 'Host' header override per origin.
             */
            Host?: Array<string>;
        }
    }
}
export interface PoolPreviewParams {
    /**
     * The expected HTTP response code or code range of the health check. This
     * parameter is only valid for HTTP and HTTPS monitors.
     */
    expected_codes: string;
    /**
     * Do not validate the certificate when monitor use HTTPS. This parameter is
     * currently only valid for HTTP and HTTPS monitors.
     */
    allow_insecure?: boolean;
    /**
     * To be marked unhealthy the monitored origin must fail this healthcheck N
     * consecutive times.
     */
    consecutive_down?: number;
    /**
     * To be marked healthy the monitored origin must pass this healthcheck N
     * consecutive times.
     */
    consecutive_up?: number;
    /**
     * Object description.
     */
    description?: string;
    /**
     * A case-insensitive sub-string to look for in the response body. If this string
     * is not found, the origin will be marked as unhealthy. This parameter is only
     * valid for HTTP and HTTPS monitors.
     */
    expected_body?: string;
    /**
     * Follow redirects if returned by the origin. This parameter is only valid for
     * HTTP and HTTPS monitors.
     */
    follow_redirects?: boolean;
    /**
     * The HTTP request headers to send in the health check. It is recommended you set
     * a Host header by default. The User-Agent header cannot be overridden. This
     * parameter is only valid for HTTP and HTTPS monitors.
     */
    header?: unknown;
    /**
     * The interval between each health check. Shorter intervals may improve failover
     * time, but will increase load on the origins as we check from multiple locations.
     */
    interval?: number;
    /**
     * The method to use for the health check. This defaults to 'GET' for HTTP/HTTPS
     * based checks and 'connection_established' for TCP based health checks.
     */
    method?: string;
    /**
     * The endpoint path you want to conduct a health check against. This parameter is
     * only valid for HTTP and HTTPS monitors.
     */
    path?: string;
    /**
     * The port number to connect to for the health check. Required for TCP, UDP, and
     * SMTP checks. HTTP and HTTPS checks should only define the port when using a
     * non-standard port (HTTP: default 80, HTTPS: default 443).
     */
    port?: number;
    /**
     * Assign this monitor to emulate the specified zone while probing. This parameter
     * is only valid for HTTP and HTTPS monitors.
     */
    probe_zone?: string;
    /**
     * The number of retries to attempt in case of a timeout before marking the origin
     * as unhealthy. Retries are attempted immediately.
     */
    retries?: number;
    /**
     * The timeout (in seconds) before marking the health check as failed.
     */
    timeout?: number;
    /**
     * The protocol to use for the health check. Currently supported protocols are
     * 'HTTP','HTTPS', 'TCP', 'ICMP-PING', 'UDP-ICMP', and 'SMTP'.
     */
    type?: 'http' | 'https' | 'tcp' | 'udp_icmp' | 'icmp_ping' | 'smtp';
}
export declare namespace Pools {
    export import LoadBalancingPool = PoolsAPI.LoadBalancingPool;
    export import PoolDeleteResponse = PoolsAPI.PoolDeleteResponse;
    export import PoolHealthResponse = PoolsAPI.PoolHealthResponse;
    export import PoolPreviewResponse = PoolsAPI.PoolPreviewResponse;
    export import PoolReferencesResponse = PoolsAPI.PoolReferencesResponse;
    export import LoadBalancingPoolsSinglePage = PoolsAPI.LoadBalancingPoolsSinglePage;
    export import PoolCreateParams = PoolsAPI.PoolCreateParams;
    export import PoolUpdateParams = PoolsAPI.PoolUpdateParams;
    export import PoolListParams = PoolsAPI.PoolListParams;
    export import PoolEditParams = PoolsAPI.PoolEditParams;
    export import PoolPreviewParams = PoolsAPI.PoolPreviewParams;
}
//# sourceMappingURL=pools.d.ts.map