@distilled.cloud/cloudflare 0.0.0-john

package/lib/services/load-balancers.d.ts

@@ -0,0 +1,1973 @@
+/**
+ * Cloudflare LOAD-BALANCERS API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service load-balancers
+ */
+import * as stream from "effect/Stream";
+import * as Schema from "effect/Schema";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import * as API from "../client/api.ts";
+import type { Credentials } from "../credentials.ts";
+import { type DefaultErrors } from "../errors.ts";
+export interface GetLoadBalancerRequest {
+    loadBalancerId: string;
+    zoneId: string;
+}
+export declare const GetLoadBalancerRequest: Schema.Schema<GetLoadBalancerRequest>;
+export interface GetLoadBalancerResponse {
+    id?: string | null;
+    /** Controls features that modify the routing of requests to pools and origins in response to dynamic conditions, such as during the interval between active health monitoring requests. For example, zero-d */
+    adaptiveRouting?: {
+        failoverAcrossPools?: boolean | null;
+    } | null;
+    /** A mapping of country codes to a list of pool IDs (ordered by their failover priority) for the given country. Any country not explicitly defined will fall back to using the corresponding region_pool ma */
+    countryPools?: Record<string, unknown> | null;
+    createdOn?: string | null;
+    /** A list of pool IDs ordered by their failover priority. Pools defined here are used by default, or when region_pools are not configured for a given region. */
+    defaultPools?: string[] | null;
+    /** Object description. */
+    description?: string | null;
+    /** Whether to enable (the default) this load balancer. */
+    enabled?: boolean | null;
+    /** The pool ID to use when all other pools are detected as unhealthy. */
+    fallbackPool?: string | null;
+    /** Controls location-based steering for non-proxied requests. See `steering_policy` to learn how steering is affected. */
+    locationStrategy?: {
+        mode?: "pop" | "resolver_ip" | null;
+        preferEcs?: "always" | "never" | "proximity" | "geo" | null;
+    } | null;
+    modifiedOn?: string | null;
+    /** The DNS hostname to associate with your Load Balancer. If this hostname already exists as a DNS record in Cloudflare's DNS, the Load Balancer will take precedence and the DNS record will not be used. */
+    name?: string | null;
+    /** List of networks where Load Balancer or Pool is enabled. */
+    networks?: string[] | null;
+    /** Enterprise only: A mapping of Cloudflare PoP identifiers to a list of pool IDs (ordered by their failover priority) for the PoP (datacenter). Any PoPs not explicitly defined will fall back to using th */
+    popPools?: Record<string, unknown> | null;
+    /** Whether the hostname should be gray clouded (false) or orange clouded (true). */
+    proxied?: boolean | null;
+    /** Configures pool weights.  - `steering_policy="random"`: A random pool is selected with probability proportional to pool weights. - `steering_policy="least_outstanding_requests"`: Use pool weights to s */
+    randomSteering?: {
+        defaultWeight?: number | null;
+        poolWeights?: Record<string, unknown> | null;
+    } | null;
+    /** A mapping of region codes to a list of pool IDs (ordered by their failover priority) for the given region. Any regions not explicitly defined will fall back to using default_pools. */
+    regionPools?: Record<string, unknown> | null;
+    /** BETA Field Not General Access: A list of rules for this load balancer to execute. */
+    rules?: {
+        condition?: string | null;
+        disabled?: boolean | null;
+        fixedResponse?: {
+            contentType?: string | null;
+            location?: string | null;
+            messageBody?: string | null;
+            statusCode?: number | null;
+        } | null;
+        name?: string | null;
+        overrides?: {
+            adaptiveRouting?: unknown | null;
+            countryPools?: Record<string, unknown> | null;
+            defaultPools?: string[] | null;
+            fallbackPool?: string | null;
+            locationStrategy?: unknown | null;
+            popPools?: Record<string, unknown> | null;
+            randomSteering?: unknown | null;
+            regionPools?: Record<string, unknown> | null;
+            sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header" | null;
+            sessionAffinityAttributes?: unknown | null;
+            sessionAffinityTtl?: number | null;
+            steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections" | null;
+            ttl?: number | null;
+        } | null;
+        priority?: number | null;
+        terminates?: boolean | null;
+    }[] | null;
+    /** Specifies the type of session affinity the load balancer should use unless specified as `"none"`. The supported types are: - `"cookie"`: On the first request to a proxied load balancer, a cookie is ge */
+    sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header" | null;
+    /** Configures attributes for session affinity. */
+    sessionAffinityAttributes?: {
+        drainDuration?: number | null;
+        headers?: string[] | null;
+        requireAllHeaders?: boolean | null;
+        samesite?: "Auto" | "Lax" | "None" | "Strict" | null;
+        secure?: "Auto" | "Always" | "Never" | null;
+        zeroDowntimeFailover?: "none" | "temporary" | "sticky" | null;
+    } | null;
+    /** Time, in seconds, until a client's session expires after being created. Once the expiry time has been reached, subsequent requests may get sent to a different origin server. The accepted ranges per `s */
+    sessionAffinityTtl?: number | null;
+    /** Steering Policy for this load balancer.  - `"off"`: Use `default_pools`. - `"geo"`: Use `region_pools`/`country_pools`/`pop_pools`. For non-proxied requests, the country for `country_pools` is determi */
+    steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections" | null;
+    /** Time to live (TTL) of the DNS entry for the IP address returned by this load balancer. This only applies to gray-clouded (unproxied) load balancers. */
+    ttl?: number | null;
+    zoneName?: string | null;
+}
+export declare const GetLoadBalancerResponse: Schema.Schema<GetLoadBalancerResponse>;
+export type GetLoadBalancerError = DefaultErrors;
+export declare const getLoadBalancer: API.OperationMethod<GetLoadBalancerRequest, GetLoadBalancerResponse, GetLoadBalancerError, Credentials | HttpClient.HttpClient>;
+export interface ListLoadBalancersRequest {
+    zoneId: string;
+}
+export declare const ListLoadBalancersRequest: Schema.Schema<ListLoadBalancersRequest>;
+export interface ListLoadBalancersResponse {
+    result: {
+        id?: string | null;
+        adaptiveRouting?: {
+            failoverAcrossPools?: boolean | null;
+        } | null;
+        countryPools?: Record<string, unknown> | null;
+        createdOn?: string | null;
+        defaultPools?: string[] | null;
+        description?: string | null;
+        enabled?: boolean | null;
+        fallbackPool?: string | null;
+        locationStrategy?: {
+            mode?: "pop" | "resolver_ip" | null;
+            preferEcs?: "always" | "never" | "proximity" | "geo" | null;
+        } | null;
+        modifiedOn?: string | null;
+        name?: string | null;
+        networks?: string[] | null;
+        popPools?: Record<string, unknown> | null;
+        proxied?: boolean | null;
+        randomSteering?: {
+            defaultWeight?: number | null;
+            poolWeights?: Record<string, unknown> | null;
+        } | null;
+        regionPools?: Record<string, unknown> | null;
+        rules?: {
+            condition?: string | null;
+            disabled?: boolean | null;
+            fixedResponse?: {
+                contentType?: string | null;
+                location?: string | null;
+                messageBody?: string | null;
+                statusCode?: number | null;
+            } | null;
+            name?: string | null;
+            overrides?: {
+                adaptiveRouting?: unknown | null;
+                countryPools?: Record<string, unknown> | null;
+                defaultPools?: string[] | null;
+                fallbackPool?: string | null;
+                locationStrategy?: unknown | null;
+                popPools?: Record<string, unknown> | null;
+                randomSteering?: unknown | null;
+                regionPools?: Record<string, unknown> | null;
+                sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header" | null;
+                sessionAffinityAttributes?: unknown | null;
+                sessionAffinityTtl?: number | null;
+                steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections" | null;
+                ttl?: number | null;
+            } | null;
+            priority?: number | null;
+            terminates?: boolean | null;
+        }[] | null;
+        sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header" | null;
+        sessionAffinityAttributes?: {
+            drainDuration?: number | null;
+            headers?: string[] | null;
+            requireAllHeaders?: boolean | null;
+            samesite?: "Auto" | "Lax" | "None" | "Strict" | null;
+            secure?: "Auto" | "Always" | "Never" | null;
+            zeroDowntimeFailover?: "none" | "temporary" | "sticky" | null;
+        } | null;
+        sessionAffinityTtl?: number | null;
+        steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections" | null;
+        ttl?: number | null;
+        zoneName?: string | null;
+    }[];
+}
+export declare const ListLoadBalancersResponse: Schema.Schema<ListLoadBalancersResponse>;
+export type ListLoadBalancersError = DefaultErrors;
+export declare const listLoadBalancers: API.PaginatedOperationMethod<ListLoadBalancersRequest, ListLoadBalancersResponse, ListLoadBalancersError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListLoadBalancersRequest) => stream.Stream<ListLoadBalancersResponse, ListLoadBalancersError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListLoadBalancersRequest) => stream.Stream<{
+        id?: string | null;
+        adaptiveRouting?: {
+            failoverAcrossPools?: boolean | null;
+        } | null;
+        countryPools?: Record<string, unknown> | null;
+        createdOn?: string | null;
+        defaultPools?: string[] | null;
+        description?: string | null;
+        enabled?: boolean | null;
+        fallbackPool?: string | null;
+        locationStrategy?: {
+            mode?: "pop" | "resolver_ip" | null;
+            preferEcs?: "always" | "never" | "proximity" | "geo" | null;
+        } | null;
+        modifiedOn?: string | null;
+        name?: string | null;
+        networks?: string[] | null;
+        popPools?: Record<string, unknown> | null;
+        proxied?: boolean | null;
+        randomSteering?: {
+            defaultWeight?: number | null;
+            poolWeights?: Record<string, unknown> | null;
+        } | null;
+        regionPools?: Record<string, unknown> | null;
+        rules?: {
+            condition?: string | null;
+            disabled?: boolean | null;
+            fixedResponse?: {
+                contentType?: string | null;
+                location?: string | null;
+                messageBody?: string | null;
+                statusCode?: number | null;
+            } | null;
+            name?: string | null;
+            overrides?: {
+                adaptiveRouting?: unknown | null;
+                countryPools?: Record<string, unknown> | null;
+                defaultPools?: string[] | null;
+                fallbackPool?: string | null;
+                locationStrategy?: unknown | null;
+                popPools?: Record<string, unknown> | null;
+                randomSteering?: unknown | null;
+                regionPools?: Record<string, unknown> | null;
+                sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header" | null;
+                sessionAffinityAttributes?: unknown | null;
+                sessionAffinityTtl?: number | null;
+                steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections" | null;
+                ttl?: number | null;
+            } | null;
+            priority?: number | null;
+            terminates?: boolean | null;
+        }[] | null;
+        sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header" | null;
+        sessionAffinityAttributes?: {
+            drainDuration?: number | null;
+            headers?: string[] | null;
+            requireAllHeaders?: boolean | null;
+            samesite?: "Auto" | "Lax" | "None" | "Strict" | null;
+            secure?: "Auto" | "Always" | "Never" | null;
+            zeroDowntimeFailover?: "none" | "temporary" | "sticky" | null;
+        } | null;
+        sessionAffinityTtl?: number | null;
+        steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections" | null;
+        ttl?: number | null;
+        zoneName?: string | null;
+    }, ListLoadBalancersError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreateLoadBalancerRequest {
+    /** Path param: */
+    zoneId: string;
+    /** Body param: A list of pool IDs ordered by their failover priority. Pools defined here are used by default, or when region_pools are not configured for a given region. */
+    defaultPools: string[];
+    /** Body param: The pool ID to use when all other pools are detected as unhealthy. */
+    fallbackPool: string;
+    /** Body param: The DNS hostname to associate with your Load Balancer. If this hostname already exists as a DNS record in Cloudflare's DNS, the Load Balancer will take precedence and the DNS record will n */
+    name: string;
+    /** Body param: Controls features that modify the routing of requests to pools and origins in response to dynamic conditions, such as during the interval between active health monitoring requests. For exa */
+    adaptiveRouting?: {
+        failoverAcrossPools?: boolean;
+    };
+    /** Body param: A mapping of country codes to a list of pool IDs (ordered by their failover priority) for the given country. Any country not explicitly defined will fall back to using the corresponding re */
+    countryPools?: Record<string, unknown>;
+    /** Body param: Object description. */
+    description?: string;
+    /** Body param: Controls location-based steering for non-proxied requests. See `steering_policy` to learn how steering is affected. */
+    locationStrategy?: {
+        mode?: "pop" | "resolver_ip";
+        preferEcs?: "always" | "never" | "proximity" | "geo";
+    };
+    /** Body param: List of networks where Load Balancer or Pool is enabled. */
+    networks?: string[];
+    /** Body param: Enterprise only: A mapping of Cloudflare PoP identifiers to a list of pool IDs (ordered by their failover priority) for the PoP (datacenter). Any PoPs not explicitly defined will fall back */
+    popPools?: Record<string, unknown>;
+    /** Body param: Whether the hostname should be gray clouded (false) or orange clouded (true). */
+    proxied?: boolean;
+    /** Body param: Configures pool weights.  - `steering_policy="random"`: A random pool is selected with probability proportional to pool weights. - `steering_policy="least_outstanding_requests"`: Use pool  */
+    randomSteering?: {
+        defaultWeight?: number;
+        poolWeights?: Record<string, unknown>;
+    };
+    /** Body param: A mapping of region codes to a list of pool IDs (ordered by their failover priority) for the given region. Any regions not explicitly defined will fall back to using default_pools. */
+    regionPools?: Record<string, unknown>;
+    /** Body param: BETA Field Not General Access: A list of rules for this load balancer to execute. */
+    rules?: {
+        condition?: string;
+        disabled?: boolean;
+        fixedResponse?: {
+            contentType?: string;
+            location?: string;
+            messageBody?: string;
+            statusCode?: number;
+        };
+        name?: string;
+        overrides?: {
+            adaptiveRouting?: unknown;
+            countryPools?: Record<string, unknown>;
+            defaultPools?: string[];
+            fallbackPool?: string;
+            locationStrategy?: unknown;
+            popPools?: Record<string, unknown>;
+            randomSteering?: unknown;
+            regionPools?: Record<string, unknown>;
+            sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header";
+            sessionAffinityAttributes?: unknown;
+            sessionAffinityTtl?: number;
+            steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections";
+            ttl?: number;
+        };
+        priority?: number;
+        terminates?: boolean;
+    }[];
+    /** Body param: Specifies the type of session affinity the load balancer should use unless specified as `"none"`. The supported types are: - `"cookie"`: On the first request to a proxied load balancer, a  */
+    sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header";
+    /** Body param: Configures attributes for session affinity. */
+    sessionAffinityAttributes?: {
+        drainDuration?: number;
+        headers?: string[];
+        requireAllHeaders?: boolean;
+        samesite?: "Auto" | "Lax" | "None" | "Strict";
+        secure?: "Auto" | "Always" | "Never";
+        zeroDowntimeFailover?: "none" | "temporary" | "sticky";
+    };
+    /** Body param: Time, in seconds, until a client's session expires after being created. Once the expiry time has been reached, subsequent requests may get sent to a different origin server. The accepted r */
+    sessionAffinityTtl?: number;
+    /** Body param: Steering Policy for this load balancer.  - `"off"`: Use `default_pools`. - `"geo"`: Use `region_pools`/`country_pools`/`pop_pools`. For non-proxied requests, the country for `country_pools */
+    steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections";
+    /** Body param: Time to live (TTL) of the DNS entry for the IP address returned by this load balancer. This only applies to gray-clouded (unproxied) load balancers. */
+    ttl?: number;
+}
+export declare const CreateLoadBalancerRequest: Schema.Schema<CreateLoadBalancerRequest>;
+export interface CreateLoadBalancerResponse {
+    id?: string | null;
+    /** Controls features that modify the routing of requests to pools and origins in response to dynamic conditions, such as during the interval between active health monitoring requests. For example, zero-d */
+    adaptiveRouting?: {
+        failoverAcrossPools?: boolean | null;
+    } | null;
+    /** A mapping of country codes to a list of pool IDs (ordered by their failover priority) for the given country. Any country not explicitly defined will fall back to using the corresponding region_pool ma */
+    countryPools?: Record<string, unknown> | null;
+    createdOn?: string | null;
+    /** A list of pool IDs ordered by their failover priority. Pools defined here are used by default, or when region_pools are not configured for a given region. */
+    defaultPools?: string[] | null;
+    /** Object description. */
+    description?: string | null;
+    /** Whether to enable (the default) this load balancer. */
+    enabled?: boolean | null;
+    /** The pool ID to use when all other pools are detected as unhealthy. */
+    fallbackPool?: string | null;
+    /** Controls location-based steering for non-proxied requests. See `steering_policy` to learn how steering is affected. */
+    locationStrategy?: {
+        mode?: "pop" | "resolver_ip" | null;
+        preferEcs?: "always" | "never" | "proximity" | "geo" | null;
+    } | null;
+    modifiedOn?: string | null;
+    /** The DNS hostname to associate with your Load Balancer. If this hostname already exists as a DNS record in Cloudflare's DNS, the Load Balancer will take precedence and the DNS record will not be used. */
+    name?: string | null;
+    /** List of networks where Load Balancer or Pool is enabled. */
+    networks?: string[] | null;
+    /** Enterprise only: A mapping of Cloudflare PoP identifiers to a list of pool IDs (ordered by their failover priority) for the PoP (datacenter). Any PoPs not explicitly defined will fall back to using th */
+    popPools?: Record<string, unknown> | null;
+    /** Whether the hostname should be gray clouded (false) or orange clouded (true). */
+    proxied?: boolean | null;
+    /** Configures pool weights.  - `steering_policy="random"`: A random pool is selected with probability proportional to pool weights. - `steering_policy="least_outstanding_requests"`: Use pool weights to s */
+    randomSteering?: {
+        defaultWeight?: number | null;
+        poolWeights?: Record<string, unknown> | null;
+    } | null;
+    /** A mapping of region codes to a list of pool IDs (ordered by their failover priority) for the given region. Any regions not explicitly defined will fall back to using default_pools. */
+    regionPools?: Record<string, unknown> | null;
+    /** BETA Field Not General Access: A list of rules for this load balancer to execute. */
+    rules?: {
+        condition?: string | null;
+        disabled?: boolean | null;
+        fixedResponse?: {
+            contentType?: string | null;
+            location?: string | null;
+            messageBody?: string | null;
+            statusCode?: number | null;
+        } | null;
+        name?: string | null;
+        overrides?: {
+            adaptiveRouting?: unknown | null;
+            countryPools?: Record<string, unknown> | null;
+            defaultPools?: string[] | null;
+            fallbackPool?: string | null;
+            locationStrategy?: unknown | null;
+            popPools?: Record<string, unknown> | null;
+            randomSteering?: unknown | null;
+            regionPools?: Record<string, unknown> | null;
+            sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header" | null;
+            sessionAffinityAttributes?: unknown | null;
+            sessionAffinityTtl?: number | null;
+            steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections" | null;
+            ttl?: number | null;
+        } | null;
+        priority?: number | null;
+        terminates?: boolean | null;
+    }[] | null;
+    /** Specifies the type of session affinity the load balancer should use unless specified as `"none"`. The supported types are: - `"cookie"`: On the first request to a proxied load balancer, a cookie is ge */
+    sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header" | null;
+    /** Configures attributes for session affinity. */
+    sessionAffinityAttributes?: {
+        drainDuration?: number | null;
+        headers?: string[] | null;
+        requireAllHeaders?: boolean | null;
+        samesite?: "Auto" | "Lax" | "None" | "Strict" | null;
+        secure?: "Auto" | "Always" | "Never" | null;
+        zeroDowntimeFailover?: "none" | "temporary" | "sticky" | null;
+    } | null;
+    /** Time, in seconds, until a client's session expires after being created. Once the expiry time has been reached, subsequent requests may get sent to a different origin server. The accepted ranges per `s */
+    sessionAffinityTtl?: number | null;
+    /** Steering Policy for this load balancer.  - `"off"`: Use `default_pools`. - `"geo"`: Use `region_pools`/`country_pools`/`pop_pools`. For non-proxied requests, the country for `country_pools` is determi */
+    steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections" | null;
+    /** Time to live (TTL) of the DNS entry for the IP address returned by this load balancer. This only applies to gray-clouded (unproxied) load balancers. */
+    ttl?: number | null;
+    zoneName?: string | null;
+}
+export declare const CreateLoadBalancerResponse: Schema.Schema<CreateLoadBalancerResponse>;
+export type CreateLoadBalancerError = DefaultErrors;
+export declare const createLoadBalancer: API.OperationMethod<CreateLoadBalancerRequest, CreateLoadBalancerResponse, CreateLoadBalancerError, Credentials | HttpClient.HttpClient>;
+export interface UpdateLoadBalancerRequest {
+    loadBalancerId: string;
+    /** Path param: */
+    zoneId: string;
+    /** Body param: A list of pool IDs ordered by their failover priority. Pools defined here are used by default, or when region_pools are not configured for a given region. */
+    defaultPools: string[];
+    /** Body param: The pool ID to use when all other pools are detected as unhealthy. */
+    fallbackPool: string;
+    /** Body param: The DNS hostname to associate with your Load Balancer. If this hostname already exists as a DNS record in Cloudflare's DNS, the Load Balancer will take precedence and the DNS record will n */
+    name: string;
+    /** Body param: Controls features that modify the routing of requests to pools and origins in response to dynamic conditions, such as during the interval between active health monitoring requests. For exa */
+    adaptiveRouting?: {
+        failoverAcrossPools?: boolean;
+    };
+    /** Body param: A mapping of country codes to a list of pool IDs (ordered by their failover priority) for the given country. Any country not explicitly defined will fall back to using the corresponding re */
+    countryPools?: Record<string, unknown>;
+    /** Body param: Object description. */
+    description?: string;
+    /** Body param: Whether to enable (the default) this load balancer. */
+    enabled?: boolean;
+    /** Body param: Controls location-based steering for non-proxied requests. See `steering_policy` to learn how steering is affected. */
+    locationStrategy?: {
+        mode?: "pop" | "resolver_ip";
+        preferEcs?: "always" | "never" | "proximity" | "geo";
+    };
+    /** Body param: List of networks where Load Balancer or Pool is enabled. */
+    networks?: string[];
+    /** Body param: Enterprise only: A mapping of Cloudflare PoP identifiers to a list of pool IDs (ordered by their failover priority) for the PoP (datacenter). Any PoPs not explicitly defined will fall back */
+    popPools?: Record<string, unknown>;
+    /** Body param: Whether the hostname should be gray clouded (false) or orange clouded (true). */
+    proxied?: boolean;
+    /** Body param: Configures pool weights.  - `steering_policy="random"`: A random pool is selected with probability proportional to pool weights. - `steering_policy="least_outstanding_requests"`: Use pool  */
+    randomSteering?: {
+        defaultWeight?: number;
+        poolWeights?: Record<string, unknown>;
+    };
+    /** Body param: A mapping of region codes to a list of pool IDs (ordered by their failover priority) for the given region. Any regions not explicitly defined will fall back to using default_pools. */
+    regionPools?: Record<string, unknown>;
+    /** Body param: BETA Field Not General Access: A list of rules for this load balancer to execute. */
+    rules?: {
+        condition?: string;
+        disabled?: boolean;
+        fixedResponse?: {
+            contentType?: string;
+            location?: string;
+            messageBody?: string;
+            statusCode?: number;
+        };
+        name?: string;
+        overrides?: {
+            adaptiveRouting?: unknown;
+            countryPools?: Record<string, unknown>;
+            defaultPools?: string[];
+            fallbackPool?: string;
+            locationStrategy?: unknown;
+            popPools?: Record<string, unknown>;
+            randomSteering?: unknown;
+            regionPools?: Record<string, unknown>;
+            sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header";
+            sessionAffinityAttributes?: unknown;
+            sessionAffinityTtl?: number;
+            steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections";
+            ttl?: number;
+        };
+        priority?: number;
+        terminates?: boolean;
+    }[];
+    /** Body param: Specifies the type of session affinity the load balancer should use unless specified as `"none"`. The supported types are: - `"cookie"`: On the first request to a proxied load balancer, a  */
+    sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header";
+    /** Body param: Configures attributes for session affinity. */
+    sessionAffinityAttributes?: {
+        drainDuration?: number;
+        headers?: string[];
+        requireAllHeaders?: boolean;
+        samesite?: "Auto" | "Lax" | "None" | "Strict";
+        secure?: "Auto" | "Always" | "Never";
+        zeroDowntimeFailover?: "none" | "temporary" | "sticky";
+    };
+    /** Body param: Time, in seconds, until a client's session expires after being created. Once the expiry time has been reached, subsequent requests may get sent to a different origin server. The accepted r */
+    sessionAffinityTtl?: number;
+    /** Body param: Steering Policy for this load balancer.  - `"off"`: Use `default_pools`. - `"geo"`: Use `region_pools`/`country_pools`/`pop_pools`. For non-proxied requests, the country for `country_pools */
+    steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections";
+    /** Body param: Time to live (TTL) of the DNS entry for the IP address returned by this load balancer. This only applies to gray-clouded (unproxied) load balancers. */
+    ttl?: number;
+}
+export declare const UpdateLoadBalancerRequest: Schema.Schema<UpdateLoadBalancerRequest>;
+export interface UpdateLoadBalancerResponse {
+    id?: string | null;
+    /** Controls features that modify the routing of requests to pools and origins in response to dynamic conditions, such as during the interval between active health monitoring requests. For example, zero-d */
+    adaptiveRouting?: {
+        failoverAcrossPools?: boolean | null;
+    } | null;
+    /** A mapping of country codes to a list of pool IDs (ordered by their failover priority) for the given country. Any country not explicitly defined will fall back to using the corresponding region_pool ma */
+    countryPools?: Record<string, unknown> | null;
+    createdOn?: string | null;
+    /** A list of pool IDs ordered by their failover priority. Pools defined here are used by default, or when region_pools are not configured for a given region. */
+    defaultPools?: string[] | null;
+    /** Object description. */
+    description?: string | null;
+    /** Whether to enable (the default) this load balancer. */
+    enabled?: boolean | null;
+    /** The pool ID to use when all other pools are detected as unhealthy. */
+    fallbackPool?: string | null;
+    /** Controls location-based steering for non-proxied requests. See `steering_policy` to learn how steering is affected. */
+    locationStrategy?: {
+        mode?: "pop" | "resolver_ip" | null;
+        preferEcs?: "always" | "never" | "proximity" | "geo" | null;
+    } | null;
+    modifiedOn?: string | null;
+    /** The DNS hostname to associate with your Load Balancer. If this hostname already exists as a DNS record in Cloudflare's DNS, the Load Balancer will take precedence and the DNS record will not be used. */
+    name?: string | null;
+    /** List of networks where Load Balancer or Pool is enabled. */
+    networks?: string[] | null;
+    /** Enterprise only: A mapping of Cloudflare PoP identifiers to a list of pool IDs (ordered by their failover priority) for the PoP (datacenter). Any PoPs not explicitly defined will fall back to using th */
+    popPools?: Record<string, unknown> | null;
+    /** Whether the hostname should be gray clouded (false) or orange clouded (true). */
+    proxied?: boolean | null;
+    /** Configures pool weights.  - `steering_policy="random"`: A random pool is selected with probability proportional to pool weights. - `steering_policy="least_outstanding_requests"`: Use pool weights to s */
+    randomSteering?: {
+        defaultWeight?: number | null;
+        poolWeights?: Record<string, unknown> | null;
+    } | null;
+    /** A mapping of region codes to a list of pool IDs (ordered by their failover priority) for the given region. Any regions not explicitly defined will fall back to using default_pools. */
+    regionPools?: Record<string, unknown> | null;
+    /** BETA Field Not General Access: A list of rules for this load balancer to execute. */
+    rules?: {
+        condition?: string | null;
+        disabled?: boolean | null;
+        fixedResponse?: {
+            contentType?: string | null;
+            location?: string | null;
+            messageBody?: string | null;
+            statusCode?: number | null;
+        } | null;
+        name?: string | null;
+        overrides?: {
+            adaptiveRouting?: unknown | null;
+            countryPools?: Record<string, unknown> | null;
+            defaultPools?: string[] | null;
+            fallbackPool?: string | null;
+            locationStrategy?: unknown | null;
+            popPools?: Record<string, unknown> | null;
+            randomSteering?: unknown | null;
+            regionPools?: Record<string, unknown> | null;
+            sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header" | null;
+            sessionAffinityAttributes?: unknown | null;
+            sessionAffinityTtl?: number | null;
+            steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections" | null;
+            ttl?: number | null;
+        } | null;
+        priority?: number | null;
+        terminates?: boolean | null;
+    }[] | null;
+    /** Specifies the type of session affinity the load balancer should use unless specified as `"none"`. The supported types are: - `"cookie"`: On the first request to a proxied load balancer, a cookie is ge */
+    sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header" | null;
+    /** Configures attributes for session affinity. */
+    sessionAffinityAttributes?: {
+        drainDuration?: number | null;
+        headers?: string[] | null;
+        requireAllHeaders?: boolean | null;
+        samesite?: "Auto" | "Lax" | "None" | "Strict" | null;
+        secure?: "Auto" | "Always" | "Never" | null;
+        zeroDowntimeFailover?: "none" | "temporary" | "sticky" | null;
+    } | null;
+    /** Time, in seconds, until a client's session expires after being created. Once the expiry time has been reached, subsequent requests may get sent to a different origin server. The accepted ranges per `s */
+    sessionAffinityTtl?: number | null;
+    /** Steering Policy for this load balancer.  - `"off"`: Use `default_pools`. - `"geo"`: Use `region_pools`/`country_pools`/`pop_pools`. For non-proxied requests, the country for `country_pools` is determi */
+    steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections" | null;
+    /** Time to live (TTL) of the DNS entry for the IP address returned by this load balancer. This only applies to gray-clouded (unproxied) load balancers. */
+    ttl?: number | null;
+    zoneName?: string | null;
+}
+export declare const UpdateLoadBalancerResponse: Schema.Schema<UpdateLoadBalancerResponse>;
+export type UpdateLoadBalancerError = DefaultErrors;
+export declare const updateLoadBalancer: API.OperationMethod<UpdateLoadBalancerRequest, UpdateLoadBalancerResponse, UpdateLoadBalancerError, Credentials | HttpClient.HttpClient>;
+export interface PatchLoadBalancerRequest {
+    loadBalancerId: string;
+    /** Path param: */
+    zoneId: string;
+    /** Body param: Controls features that modify the routing of requests to pools and origins in response to dynamic conditions, such as during the interval between active health monitoring requests. For exa */
+    adaptiveRouting?: {
+        failoverAcrossPools?: boolean;
+    };
+    /** Body param: A mapping of country codes to a list of pool IDs (ordered by their failover priority) for the given country. Any country not explicitly defined will fall back to using the corresponding re */
+    countryPools?: Record<string, unknown>;
+    /** Body param: A list of pool IDs ordered by their failover priority. Pools defined here are used by default, or when region_pools are not configured for a given region. */
+    defaultPools?: string[];
+    /** Body param: Object description. */
+    description?: string;
+    /** Body param: Whether to enable (the default) this load balancer. */
+    enabled?: boolean;
+    /** Body param: The pool ID to use when all other pools are detected as unhealthy. */
+    fallbackPool?: string;
+    /** Body param: Controls location-based steering for non-proxied requests. See `steering_policy` to learn how steering is affected. */
+    locationStrategy?: {
+        mode?: "pop" | "resolver_ip";
+        preferEcs?: "always" | "never" | "proximity" | "geo";
+    };
+    /** Body param: The DNS hostname to associate with your Load Balancer. If this hostname already exists as a DNS record in Cloudflare's DNS, the Load Balancer will take precedence and the DNS record will n */
+    name?: string;
+    /** Body param: Enterprise only: A mapping of Cloudflare PoP identifiers to a list of pool IDs (ordered by their failover priority) for the PoP (datacenter). Any PoPs not explicitly defined will fall back */
+    popPools?: Record<string, unknown>;
+    /** Body param: Whether the hostname should be gray clouded (false) or orange clouded (true). */
+    proxied?: boolean;
+    /** Body param: Configures pool weights.  - `steering_policy="random"`: A random pool is selected with probability proportional to pool weights. - `steering_policy="least_outstanding_requests"`: Use pool  */
+    randomSteering?: {
+        defaultWeight?: number;
+        poolWeights?: Record<string, unknown>;
+    };
+    /** Body param: A mapping of region codes to a list of pool IDs (ordered by their failover priority) for the given region. Any regions not explicitly defined will fall back to using default_pools. */
+    regionPools?: Record<string, unknown>;
+    /** Body param: BETA Field Not General Access: A list of rules for this load balancer to execute. */
+    rules?: {
+        condition?: string;
+        disabled?: boolean;
+        fixedResponse?: {
+            contentType?: string;
+            location?: string;
+            messageBody?: string;
+            statusCode?: number;
+        };
+        name?: string;
+        overrides?: {
+            adaptiveRouting?: unknown;
+            countryPools?: Record<string, unknown>;
+            defaultPools?: string[];
+            fallbackPool?: string;
+            locationStrategy?: unknown;
+            popPools?: Record<string, unknown>;
+            randomSteering?: unknown;
+            regionPools?: Record<string, unknown>;
+            sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header";
+            sessionAffinityAttributes?: unknown;
+            sessionAffinityTtl?: number;
+            steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections";
+            ttl?: number;
+        };
+        priority?: number;
+        terminates?: boolean;
+    }[];
+    /** Body param: Specifies the type of session affinity the load balancer should use unless specified as `"none"`. The supported types are: - `"cookie"`: On the first request to a proxied load balancer, a  */
+    sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header";
+    /** Body param: Configures attributes for session affinity. */
+    sessionAffinityAttributes?: {
+        drainDuration?: number;
+        headers?: string[];
+        requireAllHeaders?: boolean;
+        samesite?: "Auto" | "Lax" | "None" | "Strict";
+        secure?: "Auto" | "Always" | "Never";
+        zeroDowntimeFailover?: "none" | "temporary" | "sticky";
+    };
+    /** Body param: Time, in seconds, until a client's session expires after being created. Once the expiry time has been reached, subsequent requests may get sent to a different origin server. The accepted r */
+    sessionAffinityTtl?: number;
+    /** Body param: Steering Policy for this load balancer.  - `"off"`: Use `default_pools`. - `"geo"`: Use `region_pools`/`country_pools`/`pop_pools`. For non-proxied requests, the country for `country_pools */
+    steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections";
+    /** Body param: Time to live (TTL) of the DNS entry for the IP address returned by this load balancer. This only applies to gray-clouded (unproxied) load balancers. */
+    ttl?: number;
+}
+export declare const PatchLoadBalancerRequest: Schema.Schema<PatchLoadBalancerRequest>;
+export interface PatchLoadBalancerResponse {
+    id?: string | null;
+    /** Controls features that modify the routing of requests to pools and origins in response to dynamic conditions, such as during the interval between active health monitoring requests. For example, zero-d */
+    adaptiveRouting?: {
+        failoverAcrossPools?: boolean | null;
+    } | null;
+    /** A mapping of country codes to a list of pool IDs (ordered by their failover priority) for the given country. Any country not explicitly defined will fall back to using the corresponding region_pool ma */
+    countryPools?: Record<string, unknown> | null;
+    createdOn?: string | null;
+    /** A list of pool IDs ordered by their failover priority. Pools defined here are used by default, or when region_pools are not configured for a given region. */
+    defaultPools?: string[] | null;
+    /** Object description. */
+    description?: string | null;
+    /** Whether to enable (the default) this load balancer. */
+    enabled?: boolean | null;
+    /** The pool ID to use when all other pools are detected as unhealthy. */
+    fallbackPool?: string | null;
+    /** Controls location-based steering for non-proxied requests. See `steering_policy` to learn how steering is affected. */
+    locationStrategy?: {
+        mode?: "pop" | "resolver_ip" | null;
+        preferEcs?: "always" | "never" | "proximity" | "geo" | null;
+    } | null;
+    modifiedOn?: string | null;
+    /** The DNS hostname to associate with your Load Balancer. If this hostname already exists as a DNS record in Cloudflare's DNS, the Load Balancer will take precedence and the DNS record will not be used. */
+    name?: string | null;
+    /** List of networks where Load Balancer or Pool is enabled. */
+    networks?: string[] | null;
+    /** Enterprise only: A mapping of Cloudflare PoP identifiers to a list of pool IDs (ordered by their failover priority) for the PoP (datacenter). Any PoPs not explicitly defined will fall back to using th */
+    popPools?: Record<string, unknown> | null;
+    /** Whether the hostname should be gray clouded (false) or orange clouded (true). */
+    proxied?: boolean | null;
+    /** Configures pool weights.  - `steering_policy="random"`: A random pool is selected with probability proportional to pool weights. - `steering_policy="least_outstanding_requests"`: Use pool weights to s */
+    randomSteering?: {
+        defaultWeight?: number | null;
+        poolWeights?: Record<string, unknown> | null;
+    } | null;
+    /** A mapping of region codes to a list of pool IDs (ordered by their failover priority) for the given region. Any regions not explicitly defined will fall back to using default_pools. */
+    regionPools?: Record<string, unknown> | null;
+    /** BETA Field Not General Access: A list of rules for this load balancer to execute. */
+    rules?: {
+        condition?: string | null;
+        disabled?: boolean | null;
+        fixedResponse?: {
+            contentType?: string | null;
+            location?: string | null;
+            messageBody?: string | null;
+            statusCode?: number | null;
+        } | null;
+        name?: string | null;
+        overrides?: {
+            adaptiveRouting?: unknown | null;
+            countryPools?: Record<string, unknown> | null;
+            defaultPools?: string[] | null;
+            fallbackPool?: string | null;
+            locationStrategy?: unknown | null;
+            popPools?: Record<string, unknown> | null;
+            randomSteering?: unknown | null;
+            regionPools?: Record<string, unknown> | null;
+            sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header" | null;
+            sessionAffinityAttributes?: unknown | null;
+            sessionAffinityTtl?: number | null;
+            steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections" | null;
+            ttl?: number | null;
+        } | null;
+        priority?: number | null;
+        terminates?: boolean | null;
+    }[] | null;
+    /** Specifies the type of session affinity the load balancer should use unless specified as `"none"`. The supported types are: - `"cookie"`: On the first request to a proxied load balancer, a cookie is ge */
+    sessionAffinity?: "none" | "cookie" | "ip_cookie" | "header" | null;
+    /** Configures attributes for session affinity. */
+    sessionAffinityAttributes?: {
+        drainDuration?: number | null;
+        headers?: string[] | null;
+        requireAllHeaders?: boolean | null;
+        samesite?: "Auto" | "Lax" | "None" | "Strict" | null;
+        secure?: "Auto" | "Always" | "Never" | null;
+        zeroDowntimeFailover?: "none" | "temporary" | "sticky" | null;
+    } | null;
+    /** Time, in seconds, until a client's session expires after being created. Once the expiry time has been reached, subsequent requests may get sent to a different origin server. The accepted ranges per `s */
+    sessionAffinityTtl?: number | null;
+    /** Steering Policy for this load balancer.  - `"off"`: Use `default_pools`. - `"geo"`: Use `region_pools`/`country_pools`/`pop_pools`. For non-proxied requests, the country for `country_pools` is determi */
+    steeringPolicy?: "" | "off" | "geo" | "random" | "dynamic_latency" | "proximity" | "least_outstanding_requests" | "least_connections" | null;
+    /** Time to live (TTL) of the DNS entry for the IP address returned by this load balancer. This only applies to gray-clouded (unproxied) load balancers. */
+    ttl?: number | null;
+    zoneName?: string | null;
+}
+export declare const PatchLoadBalancerResponse: Schema.Schema<PatchLoadBalancerResponse>;
+export type PatchLoadBalancerError = DefaultErrors;
+export declare const patchLoadBalancer: API.OperationMethod<PatchLoadBalancerRequest, PatchLoadBalancerResponse, PatchLoadBalancerError, Credentials | HttpClient.HttpClient>;
+export interface DeleteLoadBalancerRequest {
+    loadBalancerId: string;
+    zoneId: string;
+}
+export declare const DeleteLoadBalancerRequest: Schema.Schema<DeleteLoadBalancerRequest>;
+export interface DeleteLoadBalancerResponse {
+    id?: string | null;
+}
+export declare const DeleteLoadBalancerResponse: Schema.Schema<DeleteLoadBalancerResponse>;
+export type DeleteLoadBalancerError = DefaultErrors;
+export declare const deleteLoadBalancer: API.OperationMethod<DeleteLoadBalancerRequest, DeleteLoadBalancerResponse, DeleteLoadBalancerError, Credentials | HttpClient.HttpClient>;
+export interface GetMonitorRequest {
+    monitorId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetMonitorRequest: Schema.Schema<GetMonitorRequest>;
+export interface GetMonitorResponse {
+    id?: string | null;
+    /** Do not validate the certificate when monitor use HTTPS. This parameter is currently only valid for HTTP and HTTPS monitors. */
+    allowInsecure?: boolean | null;
+    /** To be marked unhealthy the monitored origin must fail this healthcheck N consecutive times. */
+    consecutiveDown?: number | null;
+    /** To be marked healthy the monitored origin must pass this healthcheck N consecutive times. */
+    consecutiveUp?: number | null;
+    createdOn?: string | null;
+    /** Object description. */
+    description?: string | null;
+    /** 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. */
+    expectedBody?: string | null;
+    /** The expected HTTP response code or code range of the health check. This parameter is only valid for HTTP and HTTPS monitors. */
+    expectedCodes?: string | null;
+    /** Follow redirects if returned by the origin. This parameter is only valid for HTTP and HTTPS monitors. */
+    followRedirects?: boolean | null;
+    /** 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 mo */
+    header?: Record<string, unknown> | null;
+    /** 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 | null;
+    /** 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 | null;
+    modifiedOn?: string | null;
+    /** The endpoint path you want to conduct a health check against. This parameter is only valid for HTTP and HTTPS monitors. */
+    path?: string | null;
+    /** 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: d */
+    port?: number | null;
+    /** Assign this monitor to emulate the specified zone while probing. This parameter is only valid for HTTP and HTTPS monitors. */
+    probeZone?: string | null;
+    /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+    retries?: number | null;
+    /** The timeout (in seconds) before marking the health check as failed. */
+    timeout?: number | null;
+    /** 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" | null;
+}
+export declare const GetMonitorResponse: Schema.Schema<GetMonitorResponse>;
+export type GetMonitorError = DefaultErrors;
+export declare const getMonitor: API.OperationMethod<GetMonitorRequest, GetMonitorResponse, GetMonitorError, Credentials | HttpClient.HttpClient>;
+export interface ListMonitorsRequest {
+    /** Identifier. */
+    accountId: string;
+}
+export declare const ListMonitorsRequest: Schema.Schema<ListMonitorsRequest>;
+export interface ListMonitorsResponse {
+    result: {
+        id?: string | null;
+        allowInsecure?: boolean | null;
+        consecutiveDown?: number | null;
+        consecutiveUp?: number | null;
+        createdOn?: string | null;
+        description?: string | null;
+        expectedBody?: string | null;
+        expectedCodes?: string | null;
+        followRedirects?: boolean | null;
+        header?: Record<string, unknown> | null;
+        interval?: number | null;
+        method?: string | null;
+        modifiedOn?: string | null;
+        path?: string | null;
+        port?: number | null;
+        probeZone?: string | null;
+        retries?: number | null;
+        timeout?: number | null;
+        type?: "http" | "https" | "tcp" | "udp_icmp" | "icmp_ping" | "smtp" | null;
+    }[];
+}
+export declare const ListMonitorsResponse: Schema.Schema<ListMonitorsResponse>;
+export type ListMonitorsError = DefaultErrors;
+export declare const listMonitors: API.PaginatedOperationMethod<ListMonitorsRequest, ListMonitorsResponse, ListMonitorsError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListMonitorsRequest) => stream.Stream<ListMonitorsResponse, ListMonitorsError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListMonitorsRequest) => stream.Stream<{
+        id?: string | null;
+        allowInsecure?: boolean | null;
+        consecutiveDown?: number | null;
+        consecutiveUp?: number | null;
+        createdOn?: string | null;
+        description?: string | null;
+        expectedBody?: string | null;
+        expectedCodes?: string | null;
+        followRedirects?: boolean | null;
+        header?: Record<string, unknown> | null;
+        interval?: number | null;
+        method?: string | null;
+        modifiedOn?: string | null;
+        path?: string | null;
+        port?: number | null;
+        probeZone?: string | null;
+        retries?: number | null;
+        timeout?: number | null;
+        type?: "http" | "https" | "tcp" | "udp_icmp" | "icmp_ping" | "smtp" | null;
+    }, ListMonitorsError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreateMonitorRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: Do not validate the certificate when monitor use HTTPS. This parameter is currently only valid for HTTP and HTTPS monitors. */
+    allowInsecure?: boolean;
+    /** Body param: To be marked unhealthy the monitored origin must fail this healthcheck N consecutive times. */
+    consecutiveDown?: number;
+    /** Body param: To be marked healthy the monitored origin must pass this healthcheck N consecutive times. */
+    consecutiveUp?: number;
+    /** Body param: Object description. */
+    description?: string;
+    /** Body param: 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 monitor */
+    expectedBody?: string;
+    /** Body param: The expected HTTP response code or code range of the health check. This parameter is only valid for HTTP and HTTPS monitors. */
+    expectedCodes?: string;
+    /** Body param: Follow redirects if returned by the origin. This parameter is only valid for HTTP and HTTPS monitors. */
+    followRedirects?: boolean;
+    /** Body param: 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  */
+    header?: Record<string, unknown>;
+    /** Body param: 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;
+    /** Body param: 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;
+    /** Body param: The endpoint path you want to conduct a health check against. This parameter is only valid for HTTP and HTTPS monitors. */
+    path?: string;
+    /** Body param: 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  */
+    port?: number | null;
+    /** Body param: Assign this monitor to emulate the specified zone while probing. This parameter is only valid for HTTP and HTTPS monitors. */
+    probeZone?: string;
+    /** Body param: The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+    retries?: number;
+    /** Body param: The timeout (in seconds) before marking the health check as failed. */
+    timeout?: number;
+    /** Body param: 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 const CreateMonitorRequest: Schema.Schema<CreateMonitorRequest>;
+export interface CreateMonitorResponse {
+    id?: string | null;
+    /** Do not validate the certificate when monitor use HTTPS. This parameter is currently only valid for HTTP and HTTPS monitors. */
+    allowInsecure?: boolean | null;
+    /** To be marked unhealthy the monitored origin must fail this healthcheck N consecutive times. */
+    consecutiveDown?: number | null;
+    /** To be marked healthy the monitored origin must pass this healthcheck N consecutive times. */
+    consecutiveUp?: number | null;
+    createdOn?: string | null;
+    /** Object description. */
+    description?: string | null;
+    /** 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. */
+    expectedBody?: string | null;
+    /** The expected HTTP response code or code range of the health check. This parameter is only valid for HTTP and HTTPS monitors. */
+    expectedCodes?: string | null;
+    /** Follow redirects if returned by the origin. This parameter is only valid for HTTP and HTTPS monitors. */
+    followRedirects?: boolean | null;
+    /** 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 mo */
+    header?: Record<string, unknown> | null;
+    /** 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 | null;
+    /** 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 | null;
+    modifiedOn?: string | null;
+    /** The endpoint path you want to conduct a health check against. This parameter is only valid for HTTP and HTTPS monitors. */
+    path?: string | null;
+    /** 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: d */
+    port?: number | null;
+    /** Assign this monitor to emulate the specified zone while probing. This parameter is only valid for HTTP and HTTPS monitors. */
+    probeZone?: string | null;
+    /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+    retries?: number | null;
+    /** The timeout (in seconds) before marking the health check as failed. */
+    timeout?: number | null;
+    /** 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" | null;
+}
+export declare const CreateMonitorResponse: Schema.Schema<CreateMonitorResponse>;
+export type CreateMonitorError = DefaultErrors;
+export declare const createMonitor: API.OperationMethod<CreateMonitorRequest, CreateMonitorResponse, CreateMonitorError, Credentials | HttpClient.HttpClient>;
+export interface UpdateMonitorRequest {
+    monitorId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: Do not validate the certificate when monitor use HTTPS. This parameter is currently only valid for HTTP and HTTPS monitors. */
+    allowInsecure?: boolean;
+    /** Body param: To be marked unhealthy the monitored origin must fail this healthcheck N consecutive times. */
+    consecutiveDown?: number;
+    /** Body param: To be marked healthy the monitored origin must pass this healthcheck N consecutive times. */
+    consecutiveUp?: number;
+    /** Body param: Object description. */
+    description?: string;
+    /** Body param: 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 monitor */
+    expectedBody?: string;
+    /** Body param: The expected HTTP response code or code range of the health check. This parameter is only valid for HTTP and HTTPS monitors. */
+    expectedCodes?: string;
+    /** Body param: Follow redirects if returned by the origin. This parameter is only valid for HTTP and HTTPS monitors. */
+    followRedirects?: boolean;
+    /** Body param: 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  */
+    header?: Record<string, unknown>;
+    /** Body param: 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;
+    /** Body param: 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;
+    /** Body param: The endpoint path you want to conduct a health check against. This parameter is only valid for HTTP and HTTPS monitors. */
+    path?: string;
+    /** Body param: 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  */
+    port?: number | null;
+    /** Body param: Assign this monitor to emulate the specified zone while probing. This parameter is only valid for HTTP and HTTPS monitors. */
+    probeZone?: string;
+    /** Body param: The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+    retries?: number;
+    /** Body param: The timeout (in seconds) before marking the health check as failed. */
+    timeout?: number;
+    /** Body param: 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 const UpdateMonitorRequest: Schema.Schema<UpdateMonitorRequest>;
+export interface UpdateMonitorResponse {
+    id?: string | null;
+    /** Do not validate the certificate when monitor use HTTPS. This parameter is currently only valid for HTTP and HTTPS monitors. */
+    allowInsecure?: boolean | null;
+    /** To be marked unhealthy the monitored origin must fail this healthcheck N consecutive times. */
+    consecutiveDown?: number | null;
+    /** To be marked healthy the monitored origin must pass this healthcheck N consecutive times. */
+    consecutiveUp?: number | null;
+    createdOn?: string | null;
+    /** Object description. */
+    description?: string | null;
+    /** 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. */
+    expectedBody?: string | null;
+    /** The expected HTTP response code or code range of the health check. This parameter is only valid for HTTP and HTTPS monitors. */
+    expectedCodes?: string | null;
+    /** Follow redirects if returned by the origin. This parameter is only valid for HTTP and HTTPS monitors. */
+    followRedirects?: boolean | null;
+    /** 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 mo */
+    header?: Record<string, unknown> | null;
+    /** 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 | null;
+    /** 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 | null;
+    modifiedOn?: string | null;
+    /** The endpoint path you want to conduct a health check against. This parameter is only valid for HTTP and HTTPS monitors. */
+    path?: string | null;
+    /** 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: d */
+    port?: number | null;
+    /** Assign this monitor to emulate the specified zone while probing. This parameter is only valid for HTTP and HTTPS monitors. */
+    probeZone?: string | null;
+    /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+    retries?: number | null;
+    /** The timeout (in seconds) before marking the health check as failed. */
+    timeout?: number | null;
+    /** 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" | null;
+}
+export declare const UpdateMonitorResponse: Schema.Schema<UpdateMonitorResponse>;
+export type UpdateMonitorError = DefaultErrors;
+export declare const updateMonitor: API.OperationMethod<UpdateMonitorRequest, UpdateMonitorResponse, UpdateMonitorError, Credentials | HttpClient.HttpClient>;
+export interface PatchMonitorRequest {
+    monitorId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: Do not validate the certificate when monitor use HTTPS. This parameter is currently only valid for HTTP and HTTPS monitors. */
+    allowInsecure?: boolean;
+    /** Body param: To be marked unhealthy the monitored origin must fail this healthcheck N consecutive times. */
+    consecutiveDown?: number;
+    /** Body param: To be marked healthy the monitored origin must pass this healthcheck N consecutive times. */
+    consecutiveUp?: number;
+    /** Body param: Object description. */
+    description?: string;
+    /** Body param: 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 monitor */
+    expectedBody?: string;
+    /** Body param: The expected HTTP response code or code range of the health check. This parameter is only valid for HTTP and HTTPS monitors. */
+    expectedCodes?: string;
+    /** Body param: Follow redirects if returned by the origin. This parameter is only valid for HTTP and HTTPS monitors. */
+    followRedirects?: boolean;
+    /** Body param: 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  */
+    header?: Record<string, unknown>;
+    /** Body param: 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;
+    /** Body param: 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;
+    /** Body param: The endpoint path you want to conduct a health check against. This parameter is only valid for HTTP and HTTPS monitors. */
+    path?: string;
+    /** Body param: 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  */
+    port?: number | null;
+    /** Body param: Assign this monitor to emulate the specified zone while probing. This parameter is only valid for HTTP and HTTPS monitors. */
+    probeZone?: string;
+    /** Body param: The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+    retries?: number;
+    /** Body param: The timeout (in seconds) before marking the health check as failed. */
+    timeout?: number;
+    /** Body param: 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 const PatchMonitorRequest: Schema.Schema<PatchMonitorRequest>;
+export interface PatchMonitorResponse {
+    id?: string | null;
+    /** Do not validate the certificate when monitor use HTTPS. This parameter is currently only valid for HTTP and HTTPS monitors. */
+    allowInsecure?: boolean | null;
+    /** To be marked unhealthy the monitored origin must fail this healthcheck N consecutive times. */
+    consecutiveDown?: number | null;
+    /** To be marked healthy the monitored origin must pass this healthcheck N consecutive times. */
+    consecutiveUp?: number | null;
+    createdOn?: string | null;
+    /** Object description. */
+    description?: string | null;
+    /** 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. */
+    expectedBody?: string | null;
+    /** The expected HTTP response code or code range of the health check. This parameter is only valid for HTTP and HTTPS monitors. */
+    expectedCodes?: string | null;
+    /** Follow redirects if returned by the origin. This parameter is only valid for HTTP and HTTPS monitors. */
+    followRedirects?: boolean | null;
+    /** 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 mo */
+    header?: Record<string, unknown> | null;
+    /** 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 | null;
+    /** 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 | null;
+    modifiedOn?: string | null;
+    /** The endpoint path you want to conduct a health check against. This parameter is only valid for HTTP and HTTPS monitors. */
+    path?: string | null;
+    /** 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: d */
+    port?: number | null;
+    /** Assign this monitor to emulate the specified zone while probing. This parameter is only valid for HTTP and HTTPS monitors. */
+    probeZone?: string | null;
+    /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+    retries?: number | null;
+    /** The timeout (in seconds) before marking the health check as failed. */
+    timeout?: number | null;
+    /** 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" | null;
+}
+export declare const PatchMonitorResponse: Schema.Schema<PatchMonitorResponse>;
+export type PatchMonitorError = DefaultErrors;
+export declare const patchMonitor: API.OperationMethod<PatchMonitorRequest, PatchMonitorResponse, PatchMonitorError, Credentials | HttpClient.HttpClient>;
+export interface DeleteMonitorRequest {
+    monitorId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const DeleteMonitorRequest: Schema.Schema<DeleteMonitorRequest>;
+export interface DeleteMonitorResponse {
+    id?: string | null;
+}
+export declare const DeleteMonitorResponse: Schema.Schema<DeleteMonitorResponse>;
+export type DeleteMonitorError = DefaultErrors;
+export declare const deleteMonitor: API.OperationMethod<DeleteMonitorRequest, DeleteMonitorResponse, DeleteMonitorError, Credentials | HttpClient.HttpClient>;
+export interface GetMonitorGroupRequest {
+    monitorGroupId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetMonitorGroupRequest: Schema.Schema<GetMonitorGroupRequest>;
+export interface GetMonitorGroupResponse {
+    /** The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    id: string;
+    /** A short description of the monitor group */
+    description: string;
+    /** List of monitors in this group */
+    members: {
+        enabled: boolean;
+        monitorId: string;
+        monitoringOnly: boolean;
+        mustBeHealthy: boolean;
+        createdAt?: string | null;
+        updatedAt?: string | null;
+    }[];
+    /** The timestamp of when the monitor group was created */
+    createdAt?: string | null;
+    /** The timestamp of when the monitor group was last updated */
+    updatedAt?: string | null;
+}
+export declare const GetMonitorGroupResponse: Schema.Schema<GetMonitorGroupResponse>;
+export type GetMonitorGroupError = DefaultErrors;
+export declare const getMonitorGroup: API.OperationMethod<GetMonitorGroupRequest, GetMonitorGroupResponse, GetMonitorGroupError, Credentials | HttpClient.HttpClient>;
+export interface ListMonitorGroupsRequest {
+    /** Identifier. */
+    accountId: string;
+}
+export declare const ListMonitorGroupsRequest: Schema.Schema<ListMonitorGroupsRequest>;
+export interface ListMonitorGroupsResponse {
+    result: {
+        id: string;
+        description: string;
+        members: {
+            enabled: boolean;
+            monitorId: string;
+            monitoringOnly: boolean;
+            mustBeHealthy: boolean;
+            createdAt?: string | null;
+            updatedAt?: string | null;
+        }[];
+        createdAt?: string | null;
+        updatedAt?: string | null;
+    }[];
+}
+export declare const ListMonitorGroupsResponse: Schema.Schema<ListMonitorGroupsResponse>;
+export type ListMonitorGroupsError = DefaultErrors;
+export declare const listMonitorGroups: API.PaginatedOperationMethod<ListMonitorGroupsRequest, ListMonitorGroupsResponse, ListMonitorGroupsError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListMonitorGroupsRequest) => stream.Stream<ListMonitorGroupsResponse, ListMonitorGroupsError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListMonitorGroupsRequest) => stream.Stream<{
+        id: string;
+        description: string;
+        members: {
+            enabled: boolean;
+            monitorId: string;
+            monitoringOnly: boolean;
+            mustBeHealthy: boolean;
+            createdAt?: string | null;
+            updatedAt?: string | null;
+        }[];
+        createdAt?: string | null;
+        updatedAt?: string | null;
+    }, ListMonitorGroupsError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreateMonitorGroupRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    id: string;
+    /** Body param: A short description of the monitor group */
+    description: string;
+    /** Body param: List of monitors in this group */
+    members: {
+        enabled: boolean;
+        monitorId: string;
+        monitoringOnly: boolean;
+        mustBeHealthy: boolean;
+    }[];
+}
+export declare const CreateMonitorGroupRequest: Schema.Schema<CreateMonitorGroupRequest>;
+export interface CreateMonitorGroupResponse {
+    /** The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    id: string;
+    /** A short description of the monitor group */
+    description: string;
+    /** List of monitors in this group */
+    members: {
+        enabled: boolean;
+        monitorId: string;
+        monitoringOnly: boolean;
+        mustBeHealthy: boolean;
+        createdAt?: string | null;
+        updatedAt?: string | null;
+    }[];
+    /** The timestamp of when the monitor group was created */
+    createdAt?: string | null;
+    /** The timestamp of when the monitor group was last updated */
+    updatedAt?: string | null;
+}
+export declare const CreateMonitorGroupResponse: Schema.Schema<CreateMonitorGroupResponse>;
+export type CreateMonitorGroupError = DefaultErrors;
+export declare const createMonitorGroup: API.OperationMethod<CreateMonitorGroupRequest, CreateMonitorGroupResponse, CreateMonitorGroupError, Credentials | HttpClient.HttpClient>;
+export interface UpdateMonitorGroupRequest {
+    monitorGroupId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    id: string;
+    /** Body param: A short description of the monitor group */
+    description: string;
+    /** Body param: List of monitors in this group */
+    members: {
+        enabled: boolean;
+        monitorId: string;
+        monitoringOnly: boolean;
+        mustBeHealthy: boolean;
+    }[];
+}
+export declare const UpdateMonitorGroupRequest: Schema.Schema<UpdateMonitorGroupRequest>;
+export interface UpdateMonitorGroupResponse {
+    /** The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    id: string;
+    /** A short description of the monitor group */
+    description: string;
+    /** List of monitors in this group */
+    members: {
+        enabled: boolean;
+        monitorId: string;
+        monitoringOnly: boolean;
+        mustBeHealthy: boolean;
+        createdAt?: string | null;
+        updatedAt?: string | null;
+    }[];
+    /** The timestamp of when the monitor group was created */
+    createdAt?: string | null;
+    /** The timestamp of when the monitor group was last updated */
+    updatedAt?: string | null;
+}
+export declare const UpdateMonitorGroupResponse: Schema.Schema<UpdateMonitorGroupResponse>;
+export type UpdateMonitorGroupError = DefaultErrors;
+export declare const updateMonitorGroup: API.OperationMethod<UpdateMonitorGroupRequest, UpdateMonitorGroupResponse, UpdateMonitorGroupError, Credentials | HttpClient.HttpClient>;
+export interface PatchMonitorGroupRequest {
+    monitorGroupId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    id: string;
+    /** Body param: A short description of the monitor group */
+    description: string;
+    /** Body param: List of monitors in this group */
+    members: {
+        enabled: boolean;
+        monitorId: string;
+        monitoringOnly: boolean;
+        mustBeHealthy: boolean;
+    }[];
+}
+export declare const PatchMonitorGroupRequest: Schema.Schema<PatchMonitorGroupRequest>;
+export interface PatchMonitorGroupResponse {
+    /** The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    id: string;
+    /** A short description of the monitor group */
+    description: string;
+    /** List of monitors in this group */
+    members: {
+        enabled: boolean;
+        monitorId: string;
+        monitoringOnly: boolean;
+        mustBeHealthy: boolean;
+        createdAt?: string | null;
+        updatedAt?: string | null;
+    }[];
+    /** The timestamp of when the monitor group was created */
+    createdAt?: string | null;
+    /** The timestamp of when the monitor group was last updated */
+    updatedAt?: string | null;
+}
+export declare const PatchMonitorGroupResponse: Schema.Schema<PatchMonitorGroupResponse>;
+export type PatchMonitorGroupError = DefaultErrors;
+export declare const patchMonitorGroup: API.OperationMethod<PatchMonitorGroupRequest, PatchMonitorGroupResponse, PatchMonitorGroupError, Credentials | HttpClient.HttpClient>;
+export interface DeleteMonitorGroupRequest {
+    monitorGroupId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const DeleteMonitorGroupRequest: Schema.Schema<DeleteMonitorGroupRequest>;
+export interface DeleteMonitorGroupResponse {
+    /** The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    id: string;
+    /** A short description of the monitor group */
+    description: string;
+    /** List of monitors in this group */
+    members: {
+        enabled: boolean;
+        monitorId: string;
+        monitoringOnly: boolean;
+        mustBeHealthy: boolean;
+        createdAt?: string | null;
+        updatedAt?: string | null;
+    }[];
+    /** The timestamp of when the monitor group was created */
+    createdAt?: string | null;
+    /** The timestamp of when the monitor group was last updated */
+    updatedAt?: string | null;
+}
+export declare const DeleteMonitorGroupResponse: Schema.Schema<DeleteMonitorGroupResponse>;
+export type DeleteMonitorGroupError = DefaultErrors;
+export declare const deleteMonitorGroup: API.OperationMethod<DeleteMonitorGroupRequest, DeleteMonitorGroupResponse, DeleteMonitorGroupError, Credentials | HttpClient.HttpClient>;
+export interface CreateMonitorPreviewRequest {
+    monitorId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: Do not validate the certificate when monitor use HTTPS. This parameter is currently only valid for HTTP and HTTPS monitors. */
+    allowInsecure?: boolean;
+    /** Body param: To be marked unhealthy the monitored origin must fail this healthcheck N consecutive times. */
+    consecutiveDown?: number;
+    /** Body param: To be marked healthy the monitored origin must pass this healthcheck N consecutive times. */
+    consecutiveUp?: number;
+    /** Body param: Object description. */
+    description?: string;
+    /** Body param: 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 monitor */
+    expectedBody?: string;
+    /** Body param: The expected HTTP response code or code range of the health check. This parameter is only valid for HTTP and HTTPS monitors. */
+    expectedCodes?: string;
+    /** Body param: Follow redirects if returned by the origin. This parameter is only valid for HTTP and HTTPS monitors. */
+    followRedirects?: boolean;
+    /** Body param: 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  */
+    header?: Record<string, unknown>;
+    /** Body param: 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;
+    /** Body param: 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;
+    /** Body param: The endpoint path you want to conduct a health check against. This parameter is only valid for HTTP and HTTPS monitors. */
+    path?: string;
+    /** Body param: 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  */
+    port?: number | null;
+    /** Body param: Assign this monitor to emulate the specified zone while probing. This parameter is only valid for HTTP and HTTPS monitors. */
+    probeZone?: string;
+    /** Body param: The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+    retries?: number;
+    /** Body param: The timeout (in seconds) before marking the health check as failed. */
+    timeout?: number;
+    /** Body param: 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 const CreateMonitorPreviewRequest: Schema.Schema<CreateMonitorPreviewRequest>;
+export interface CreateMonitorPreviewResponse {
+    /** Monitored pool IDs mapped to their respective names. */
+    pools?: Record<string, unknown> | null;
+    previewId?: string | null;
+}
+export declare const CreateMonitorPreviewResponse: Schema.Schema<CreateMonitorPreviewResponse>;
+export type CreateMonitorPreviewError = DefaultErrors;
+export declare const createMonitorPreview: API.OperationMethod<CreateMonitorPreviewRequest, CreateMonitorPreviewResponse, CreateMonitorPreviewError, Credentials | HttpClient.HttpClient>;
+export interface GetMonitorReferenceRequest {
+    monitorId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetMonitorReferenceRequest: Schema.Schema<GetMonitorReferenceRequest>;
+export interface GetMonitorReferenceResponse {
+    result: {
+        referenceType?: "*" | "referral" | "referrer" | null;
+        resourceId?: string | null;
+        resourceName?: string | null;
+        resourceType?: string | null;
+    }[];
+}
+export declare const GetMonitorReferenceResponse: Schema.Schema<GetMonitorReferenceResponse>;
+export type GetMonitorReferenceError = DefaultErrors;
+export declare const getMonitorReference: API.PaginatedOperationMethod<GetMonitorReferenceRequest, GetMonitorReferenceResponse, GetMonitorReferenceError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: GetMonitorReferenceRequest) => stream.Stream<GetMonitorReferenceResponse, GetMonitorReferenceError, Credentials | HttpClient.HttpClient>;
+    items: (input: GetMonitorReferenceRequest) => stream.Stream<{
+        referenceType?: "*" | "referral" | "referrer" | null;
+        resourceId?: string | null;
+        resourceName?: string | null;
+        resourceType?: string | null;
+    }, GetMonitorReferenceError, Credentials | HttpClient.HttpClient>;
+};
+export interface GetPoolRequest {
+    poolId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetPoolRequest: Schema.Schema<GetPoolRequest>;
+export interface GetPoolResponse {
+    id?: string | null;
+    /** A list of regions from which to run health checks. Null means every Cloudflare data center. */
+    checkRegions?: ("WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "SEAS" | "NEAS" | "ALL_REGIONS" | "SAS")[] | null;
+    createdOn?: string | null;
+    /** A human-readable description of the pool. */
+    description?: string | null;
+    /** This field shows up only if the pool is disabled. This field is set with the time the pool was disabled at. */
+    disabledAt?: string | null;
+    /** 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 t */
+    enabled?: boolean | null;
+    /** 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 | null;
+    /** Configures load shedding policies and percentages for the pool. */
+    loadShedding?: unknown | null;
+    /** 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 | null;
+    /** 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  */
+    minimumOrigins?: number | null;
+    modifiedOn?: string | null;
+    /** The ID of the Monitor to use for checking the health of origins within this pool. */
+    monitor?: string | null;
+    /** The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    monitorGroup?: string | null;
+    /** A short name (tag) for the pool. Only alphanumeric characters, hyphens, and underscores are allowed. */
+    name?: string | null;
+    /** List of networks where Load Balancer or Pool is enabled. */
+    networks?: string[] | null;
+    /** 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  */
+    notificationEmail?: string | null;
+    /** Filter pool and origin health notifications by resource type or health status. Use null to reset. */
+    notificationFilter?: unknown | null;
+    /** Configures origin steering for the pool. Controls how origins are selected for new sessions and traffic without session affinity. */
+    originSteering?: unknown | null;
+    /** 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?: unknown[] | null;
+}
+export declare const GetPoolResponse: Schema.Schema<GetPoolResponse>;
+export type GetPoolError = DefaultErrors;
+export declare const getPool: API.OperationMethod<GetPoolRequest, GetPoolResponse, GetPoolError, Credentials | HttpClient.HttpClient>;
+export interface ListPoolsRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Query param: The ID of the Monitor to use for checking the health of origins within this pool. */
+    monitor?: string;
+}
+export declare const ListPoolsRequest: Schema.Schema<ListPoolsRequest>;
+export interface ListPoolsResponse {
+    result: {
+        id?: string | null;
+        checkRegions?: ("WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "SEAS" | "NEAS" | "ALL_REGIONS" | "SAS")[] | null;
+        createdOn?: string | null;
+        description?: string | null;
+        disabledAt?: string | null;
+        enabled?: boolean | null;
+        latitude?: number | null;
+        loadShedding?: unknown | null;
+        longitude?: number | null;
+        minimumOrigins?: number | null;
+        modifiedOn?: string | null;
+        monitor?: string | null;
+        monitorGroup?: string | null;
+        name?: string | null;
+        networks?: string[] | null;
+        notificationEmail?: string | null;
+        notificationFilter?: unknown | null;
+        originSteering?: unknown | null;
+        origins?: unknown[] | null;
+    }[];
+}
+export declare const ListPoolsResponse: Schema.Schema<ListPoolsResponse>;
+export type ListPoolsError = DefaultErrors;
+export declare const listPools: API.PaginatedOperationMethod<ListPoolsRequest, ListPoolsResponse, ListPoolsError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListPoolsRequest) => stream.Stream<ListPoolsResponse, ListPoolsError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListPoolsRequest) => stream.Stream<{
+        id?: string | null;
+        checkRegions?: ("WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "SEAS" | "NEAS" | "ALL_REGIONS" | "SAS")[] | null;
+        createdOn?: string | null;
+        description?: string | null;
+        disabledAt?: string | null;
+        enabled?: boolean | null;
+        latitude?: number | null;
+        loadShedding?: unknown | null;
+        longitude?: number | null;
+        minimumOrigins?: number | null;
+        modifiedOn?: string | null;
+        monitor?: string | null;
+        monitorGroup?: string | null;
+        name?: string | null;
+        networks?: string[] | null;
+        notificationEmail?: string | null;
+        notificationFilter?: unknown | null;
+        originSteering?: unknown | null;
+        origins?: unknown[] | null;
+    }, ListPoolsError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreatePoolRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: A short name (tag) for the pool. Only alphanumeric characters, hyphens, and underscores are allowed. */
+    name: string;
+    /** Body param: 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: unknown[];
+    /** Body param: A human-readable description of the pool. */
+    description?: string;
+    /** Body param: 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 t */
+    enabled?: boolean;
+    /** Body param: 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;
+    /** Body param: Configures load shedding policies and percentages for the pool. */
+    loadShedding?: unknown | null;
+    /** Body param: 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;
+    /** Body param: 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 fail */
+    minimumOrigins?: number;
+    /** Body param: The ID of the Monitor to use for checking the health of origins within this pool. */
+    monitor?: string;
+    /** Body param: The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    monitorGroup?: string;
+    /** Body param: 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 he */
+    notificationEmail?: string;
+    /** Body param: Filter pool and origin health notifications by resource type or health status. Use null to reset. */
+    notificationFilter?: unknown | null;
+    /** Body param: Configures origin steering for the pool. Controls how origins are selected for new sessions and traffic without session affinity. */
+    originSteering?: unknown | null;
+}
+export declare const CreatePoolRequest: Schema.Schema<CreatePoolRequest>;
+export interface CreatePoolResponse {
+    id?: string | null;
+    /** A list of regions from which to run health checks. Null means every Cloudflare data center. */
+    checkRegions?: ("WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "SEAS" | "NEAS" | "ALL_REGIONS" | "SAS")[] | null;
+    createdOn?: string | null;
+    /** A human-readable description of the pool. */
+    description?: string | null;
+    /** This field shows up only if the pool is disabled. This field is set with the time the pool was disabled at. */
+    disabledAt?: string | null;
+    /** 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 t */
+    enabled?: boolean | null;
+    /** 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 | null;
+    /** Configures load shedding policies and percentages for the pool. */
+    loadShedding?: unknown | null;
+    /** 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 | null;
+    /** 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  */
+    minimumOrigins?: number | null;
+    modifiedOn?: string | null;
+    /** The ID of the Monitor to use for checking the health of origins within this pool. */
+    monitor?: string | null;
+    /** The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    monitorGroup?: string | null;
+    /** A short name (tag) for the pool. Only alphanumeric characters, hyphens, and underscores are allowed. */
+    name?: string | null;
+    /** List of networks where Load Balancer or Pool is enabled. */
+    networks?: string[] | null;
+    /** 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  */
+    notificationEmail?: string | null;
+    /** Filter pool and origin health notifications by resource type or health status. Use null to reset. */
+    notificationFilter?: unknown | null;
+    /** Configures origin steering for the pool. Controls how origins are selected for new sessions and traffic without session affinity. */
+    originSteering?: unknown | null;
+    /** 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?: unknown[] | null;
+}
+export declare const CreatePoolResponse: Schema.Schema<CreatePoolResponse>;
+export type CreatePoolError = DefaultErrors;
+export declare const createPool: API.OperationMethod<CreatePoolRequest, CreatePoolResponse, CreatePoolError, Credentials | HttpClient.HttpClient>;
+export interface UpdatePoolRequest {
+    poolId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: A short name (tag) for the pool. Only alphanumeric characters, hyphens, and underscores are allowed. */
+    name: string;
+    /** Body param: 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: unknown[];
+    /** Body param: A list of regions from which to run health checks. Null means every Cloudflare data center. */
+    checkRegions?: ("WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "SEAS" | "NEAS" | "ALL_REGIONS" | "SAS")[] | null;
+    /** Body param: A human-readable description of the pool. */
+    description?: string;
+    /** Body param: 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 t */
+    enabled?: boolean;
+    /** Body param: 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;
+    /** Body param: Configures load shedding policies and percentages for the pool. */
+    loadShedding?: unknown | null;
+    /** Body param: 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;
+    /** Body param: 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 fail */
+    minimumOrigins?: number;
+    /** Body param: The ID of the Monitor to use for checking the health of origins within this pool. */
+    monitor?: string;
+    /** Body param: The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    monitorGroup?: string;
+    /** Body param: 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 he */
+    notificationEmail?: string;
+    /** Body param: Filter pool and origin health notifications by resource type or health status. Use null to reset. */
+    notificationFilter?: unknown | null;
+    /** Body param: Configures origin steering for the pool. Controls how origins are selected for new sessions and traffic without session affinity. */
+    originSteering?: unknown | null;
+}
+export declare const UpdatePoolRequest: Schema.Schema<UpdatePoolRequest>;
+export interface UpdatePoolResponse {
+    id?: string | null;
+    /** A list of regions from which to run health checks. Null means every Cloudflare data center. */
+    checkRegions?: ("WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "SEAS" | "NEAS" | "ALL_REGIONS" | "SAS")[] | null;
+    createdOn?: string | null;
+    /** A human-readable description of the pool. */
+    description?: string | null;
+    /** This field shows up only if the pool is disabled. This field is set with the time the pool was disabled at. */
+    disabledAt?: string | null;
+    /** 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 t */
+    enabled?: boolean | null;
+    /** 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 | null;
+    /** Configures load shedding policies and percentages for the pool. */
+    loadShedding?: unknown | null;
+    /** 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 | null;
+    /** 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  */
+    minimumOrigins?: number | null;
+    modifiedOn?: string | null;
+    /** The ID of the Monitor to use for checking the health of origins within this pool. */
+    monitor?: string | null;
+    /** The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    monitorGroup?: string | null;
+    /** A short name (tag) for the pool. Only alphanumeric characters, hyphens, and underscores are allowed. */
+    name?: string | null;
+    /** List of networks where Load Balancer or Pool is enabled. */
+    networks?: string[] | null;
+    /** 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  */
+    notificationEmail?: string | null;
+    /** Filter pool and origin health notifications by resource type or health status. Use null to reset. */
+    notificationFilter?: unknown | null;
+    /** Configures origin steering for the pool. Controls how origins are selected for new sessions and traffic without session affinity. */
+    originSteering?: unknown | null;
+    /** 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?: unknown[] | null;
+}
+export declare const UpdatePoolResponse: Schema.Schema<UpdatePoolResponse>;
+export type UpdatePoolError = DefaultErrors;
+export declare const updatePool: API.OperationMethod<UpdatePoolRequest, UpdatePoolResponse, UpdatePoolError, Credentials | HttpClient.HttpClient>;
+export interface PatchPoolRequest {
+    poolId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: A list of regions from which to run health checks. Null means every Cloudflare data center. */
+    checkRegions?: ("WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "SEAS" | "NEAS" | "ALL_REGIONS" | "SAS")[] | null;
+    /** Body param: A human-readable description of the pool. */
+    description?: string;
+    /** Body param: 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 t */
+    enabled?: boolean;
+    /** Body param: 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;
+    /** Body param: Configures load shedding policies and percentages for the pool. */
+    loadShedding?: unknown | null;
+    /** Body param: 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;
+    /** Body param: 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 fail */
+    minimumOrigins?: number;
+    /** Body param: The ID of the Monitor to use for checking the health of origins within this pool. */
+    monitor?: string;
+    /** Body param: The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    monitorGroup?: string;
+    /** Body param: A short name (tag) for the pool. Only alphanumeric characters, hyphens, and underscores are allowed. */
+    name?: string;
+    /** Body param: 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 he */
+    notificationEmail?: string;
+    /** Body param: Filter pool and origin health notifications by resource type or health status. Use null to reset. */
+    notificationFilter?: unknown | null;
+    /** Body param: Configures origin steering for the pool. Controls how origins are selected for new sessions and traffic without session affinity. */
+    originSteering?: unknown | null;
+    /** Body param: 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?: unknown[];
+}
+export declare const PatchPoolRequest: Schema.Schema<PatchPoolRequest>;
+export interface PatchPoolResponse {
+    id?: string | null;
+    /** A list of regions from which to run health checks. Null means every Cloudflare data center. */
+    checkRegions?: ("WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "SEAS" | "NEAS" | "ALL_REGIONS" | "SAS")[] | null;
+    createdOn?: string | null;
+    /** A human-readable description of the pool. */
+    description?: string | null;
+    /** This field shows up only if the pool is disabled. This field is set with the time the pool was disabled at. */
+    disabledAt?: string | null;
+    /** 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 t */
+    enabled?: boolean | null;
+    /** 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 | null;
+    /** Configures load shedding policies and percentages for the pool. */
+    loadShedding?: unknown | null;
+    /** 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 | null;
+    /** 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  */
+    minimumOrigins?: number | null;
+    modifiedOn?: string | null;
+    /** The ID of the Monitor to use for checking the health of origins within this pool. */
+    monitor?: string | null;
+    /** The ID of the Monitor Group to use for checking the health of origins within this pool. */
+    monitorGroup?: string | null;
+    /** A short name (tag) for the pool. Only alphanumeric characters, hyphens, and underscores are allowed. */
+    name?: string | null;
+    /** List of networks where Load Balancer or Pool is enabled. */
+    networks?: string[] | null;
+    /** 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  */
+    notificationEmail?: string | null;
+    /** Filter pool and origin health notifications by resource type or health status. Use null to reset. */
+    notificationFilter?: unknown | null;
+    /** Configures origin steering for the pool. Controls how origins are selected for new sessions and traffic without session affinity. */
+    originSteering?: unknown | null;
+    /** 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?: unknown[] | null;
+}
+export declare const PatchPoolResponse: Schema.Schema<PatchPoolResponse>;
+export type PatchPoolError = DefaultErrors;
+export declare const patchPool: API.OperationMethod<PatchPoolRequest, PatchPoolResponse, PatchPoolError, Credentials | HttpClient.HttpClient>;
+export interface DeletePoolRequest {
+    poolId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const DeletePoolRequest: Schema.Schema<DeletePoolRequest>;
+export interface DeletePoolResponse {
+    id?: string | null;
+}
+export declare const DeletePoolResponse: Schema.Schema<DeletePoolResponse>;
+export type DeletePoolError = DefaultErrors;
+export declare const deletePool: API.OperationMethod<DeletePoolRequest, DeletePoolResponse, DeletePoolError, Credentials | HttpClient.HttpClient>;
+export interface BulkPatchPoolsRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: The email address to send health status notifications to. This field is now deprecated in favor of Cloudflare Notifications for Load Balancing, so only resetting this field with an empty s */
+    notificationEmail?: "";
+}
+export declare const BulkPatchPoolsRequest: Schema.Schema<BulkPatchPoolsRequest>;
+export interface BulkPatchPoolsResponse {
+    result: {
+        id?: string | null;
+        checkRegions?: ("WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "SEAS" | "NEAS" | "ALL_REGIONS" | "SAS")[] | null;
+        createdOn?: string | null;
+        description?: string | null;
+        disabledAt?: string | null;
+        enabled?: boolean | null;
+        latitude?: number | null;
+        loadShedding?: unknown | null;
+        longitude?: number | null;
+        minimumOrigins?: number | null;
+        modifiedOn?: string | null;
+        monitor?: string | null;
+        monitorGroup?: string | null;
+        name?: string | null;
+        networks?: string[] | null;
+        notificationEmail?: string | null;
+        notificationFilter?: unknown | null;
+        originSteering?: unknown | null;
+        origins?: unknown[] | null;
+    }[];
+}
+export declare const BulkPatchPoolsResponse: Schema.Schema<BulkPatchPoolsResponse>;
+export type BulkPatchPoolsError = DefaultErrors;
+export declare const bulkPatchPools: API.PaginatedOperationMethod<BulkPatchPoolsRequest, BulkPatchPoolsResponse, BulkPatchPoolsError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: BulkPatchPoolsRequest) => stream.Stream<BulkPatchPoolsResponse, BulkPatchPoolsError, Credentials | HttpClient.HttpClient>;
+    items: (input: BulkPatchPoolsRequest) => stream.Stream<{
+        id?: string | null;
+        checkRegions?: ("WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "SEAS" | "NEAS" | "ALL_REGIONS" | "SAS")[] | null;
+        createdOn?: string | null;
+        description?: string | null;
+        disabledAt?: string | null;
+        enabled?: boolean | null;
+        latitude?: number | null;
+        loadShedding?: unknown | null;
+        longitude?: number | null;
+        minimumOrigins?: number | null;
+        modifiedOn?: string | null;
+        monitor?: string | null;
+        monitorGroup?: string | null;
+        name?: string | null;
+        networks?: string[] | null;
+        notificationEmail?: string | null;
+        notificationFilter?: unknown | null;
+        originSteering?: unknown | null;
+        origins?: unknown[] | null;
+    }, BulkPatchPoolsError, Credentials | HttpClient.HttpClient>;
+};
+export interface GetPoolHealthRequest {
+    poolId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetPoolHealthRequest: Schema.Schema<GetPoolHealthRequest>;
+export interface GetPoolHealthResponse {
+    /** Pool ID. */
+    poolId?: string | null;
+    /** List of regions and associated health status. */
+    popHealth?: {
+        healthy?: boolean | null;
+        origins?: {
+            ip?: {
+                failureReason?: string | null;
+                healthy?: boolean | null;
+                responseCode?: number | null;
+                rtt?: string | null;
+            } | null;
+        }[] | null;
+    } | null;
+}
+export declare const GetPoolHealthResponse: Schema.Schema<GetPoolHealthResponse>;
+export type GetPoolHealthError = DefaultErrors;
+export declare const getPoolHealth: API.OperationMethod<GetPoolHealthRequest, GetPoolHealthResponse, GetPoolHealthError, Credentials | HttpClient.HttpClient>;
+export interface CreatePoolHealthRequest {
+    poolId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: Do not validate the certificate when monitor use HTTPS. This parameter is currently only valid for HTTP and HTTPS monitors. */
+    allowInsecure?: boolean;
+    /** Body param: To be marked unhealthy the monitored origin must fail this healthcheck N consecutive times. */
+    consecutiveDown?: number;
+    /** Body param: To be marked healthy the monitored origin must pass this healthcheck N consecutive times. */
+    consecutiveUp?: number;
+    /** Body param: Object description. */
+    description?: string;
+    /** Body param: 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 monitor */
+    expectedBody?: string;
+    /** Body param: The expected HTTP response code or code range of the health check. This parameter is only valid for HTTP and HTTPS monitors. */
+    expectedCodes?: string;
+    /** Body param: Follow redirects if returned by the origin. This parameter is only valid for HTTP and HTTPS monitors. */
+    followRedirects?: boolean;
+    /** Body param: 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  */
+    header?: Record<string, unknown>;
+    /** Body param: 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;
+    /** Body param: 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;
+    /** Body param: The endpoint path you want to conduct a health check against. This parameter is only valid for HTTP and HTTPS monitors. */
+    path?: string;
+    /** Body param: 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  */
+    port?: number | null;
+    /** Body param: Assign this monitor to emulate the specified zone while probing. This parameter is only valid for HTTP and HTTPS monitors. */
+    probeZone?: string;
+    /** Body param: The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+    retries?: number;
+    /** Body param: The timeout (in seconds) before marking the health check as failed. */
+    timeout?: number;
+    /** Body param: 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 const CreatePoolHealthRequest: Schema.Schema<CreatePoolHealthRequest>;
+export interface CreatePoolHealthResponse {
+    /** Monitored pool IDs mapped to their respective names. */
+    pools?: Record<string, unknown> | null;
+    previewId?: string | null;
+}
+export declare const CreatePoolHealthResponse: Schema.Schema<CreatePoolHealthResponse>;
+export type CreatePoolHealthError = DefaultErrors;
+export declare const createPoolHealth: API.OperationMethod<CreatePoolHealthRequest, CreatePoolHealthResponse, CreatePoolHealthError, Credentials | HttpClient.HttpClient>;
+export interface GetPoolReferenceRequest {
+    poolId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetPoolReferenceRequest: Schema.Schema<GetPoolReferenceRequest>;
+export interface GetPoolReferenceResponse {
+    result: {
+        referenceType?: "*" | "referral" | "referrer" | null;
+        resourceId?: string | null;
+        resourceName?: string | null;
+        resourceType?: string | null;
+    }[];
+}
+export declare const GetPoolReferenceResponse: Schema.Schema<GetPoolReferenceResponse>;
+export type GetPoolReferenceError = DefaultErrors;
+export declare const getPoolReference: API.PaginatedOperationMethod<GetPoolReferenceRequest, GetPoolReferenceResponse, GetPoolReferenceError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: GetPoolReferenceRequest) => stream.Stream<GetPoolReferenceResponse, GetPoolReferenceError, Credentials | HttpClient.HttpClient>;
+    items: (input: GetPoolReferenceRequest) => stream.Stream<{
+        referenceType?: "*" | "referral" | "referrer" | null;
+        resourceId?: string | null;
+        resourceName?: string | null;
+        resourceType?: string | null;
+    }, GetPoolReferenceError, Credentials | HttpClient.HttpClient>;
+};
+export interface GetPreviewRequest {
+    previewId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetPreviewRequest: Schema.Schema<GetPreviewRequest>;
+export type GetPreviewResponse = Record<string, unknown>;
+export declare const GetPreviewResponse: Schema.Schema<GetPreviewResponse>;
+export type GetPreviewError = DefaultErrors;
+export declare const getPreview: API.OperationMethod<GetPreviewRequest, GetPreviewResponse, GetPreviewError, Credentials | HttpClient.HttpClient>;
+export interface GetRegionRequest {
+    regionId: "WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "SAS" | "SEAS" | "NEAS";
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetRegionRequest: Schema.Schema<GetRegionRequest>;
+export type GetRegionResponse = string | null;
+export declare const GetRegionResponse: Schema.Schema<GetRegionResponse>;
+export type GetRegionError = DefaultErrors;
+export declare const getRegion: API.OperationMethod<GetRegionRequest, GetRegionResponse, GetRegionError, Credentials | HttpClient.HttpClient>;
+export interface ListRegionsRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Query param: Two-letter alpha-2 country code followed in ISO 3166-1. */
+    countryCodeA2?: string;
+    /** Query param: Two-letter subdivision code followed in ISO 3166-2. */
+    subdivisionCode?: string;
+    /** Query param: Two-letter subdivision code followed in ISO 3166-2. */
+    subdivisionCodeA2?: string;
+}
+export declare const ListRegionsRequest: Schema.Schema<ListRegionsRequest>;
+export type ListRegionsResponse = string | null;
+export declare const ListRegionsResponse: Schema.Schema<ListRegionsResponse>;
+export type ListRegionsError = DefaultErrors;
+export declare const listRegions: API.OperationMethod<ListRegionsRequest, ListRegionsResponse, ListRegionsError, Credentials | HttpClient.HttpClient>;
+export interface ListSearchesRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Query param: Search query term. */
+    query?: string;
+    /** Query param: The type of references to include. "\ " to include both referral and referrer references. "" to not include any reference information. */
+    references?: "" | "*" | "referral" | "referrer";
+}
+export declare const ListSearchesRequest: Schema.Schema<ListSearchesRequest>;
+export interface ListSearchesResponse {
+    result: {
+        items?: {
+            resources?: {
+                referenceType?: "referral" | "referrer" | null;
+                references?: unknown[] | null;
+                resourceId?: string | null;
+                resourceName?: string | null;
+                resourceType?: "load_balancer" | "monitor" | "pool" | null;
+            }[] | null;
+        }[] | null;
+    };
+    resultInfo: {
+        count?: number | null;
+        page?: number | null;
+        perPage?: number | null;
+        totalCount?: number | null;
+    };
+}
+export declare const ListSearchesResponse: Schema.Schema<ListSearchesResponse>;
+export type ListSearchesError = DefaultErrors;
+export declare const listSearches: API.PaginatedOperationMethod<ListSearchesRequest, ListSearchesResponse, ListSearchesError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListSearchesRequest) => stream.Stream<ListSearchesResponse, ListSearchesError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListSearchesRequest) => stream.Stream<{
+        resources?: {
+            referenceType?: "referral" | "referrer" | null;
+            references?: unknown[] | null;
+            resourceId?: string | null;
+            resourceName?: string | null;
+            resourceType?: "load_balancer" | "monitor" | "pool" | null;
+        }[] | null;
+    }, ListSearchesError, Credentials | HttpClient.HttpClient>;
+};
+//# sourceMappingURL=load-balancers.d.ts.map