cloudflare 3.1.0 → 3.4.0

package/resources/load-balancers/load-balancers.d.ts

@@ -1,12 +1,12 @@
-import * as Core from 'cloudflare/core';
-import { APIResource } from 'cloudflare/resource';
-import * as LoadBalancersAPI from 'cloudflare/resources/load-balancers/load-balancers';
-import * as PreviewsAPI from 'cloudflare/resources/load-balancers/previews';
-import * as RegionsAPI from 'cloudflare/resources/load-balancers/regions';
-import * as SearchesAPI from 'cloudflare/resources/load-balancers/searches';
-import * as MonitorsAPI from 'cloudflare/resources/load-balancers/monitors/monitors';
-import * as PoolsAPI from 'cloudflare/resources/load-balancers/pools/pools';
-import { SinglePage } from 'cloudflare/pagination';
+import * as Core from "../../core.js";
+import { APIResource } from "../../resource.js";
+import * as LoadBalancersAPI from "./load-balancers.js";
+import * as PreviewsAPI from "./previews.js";
+import * as RegionsAPI from "./regions.js";
+import * as SearchesAPI from "./searches.js";
+import * as MonitorsAPI from "./monitors/monitors.js";
+import * as PoolsAPI from "./pools/pools.js";
+import { SinglePage } from "../../pagination.js";
 export declare class LoadBalancers extends APIResource {
     monitors: MonitorsAPI.Monitors;
     pools: PoolsAPI.Pools;
@@ -59,6 +59,25 @@ export interface AdaptiveRouting {
      */
     failover_across_pools?: boolean;
 }
+/**
+ * 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-downtime failover occurs
+ * immediately when an origin becomes unavailable due to HTTP 521, 522, or 523
+ * response codes. If there is another healthy origin in the same pool, the request
+ * is retried once against this alternate origin.
+ */
+export interface AdaptiveRoutingParam {
+    /**
+     * Extends zero-downtime failover of requests to healthy origins from alternate
+     * pools, when no healthy alternate exists in the same pool, according to the
+     * failover order defined by traffic and origin steering. When set false (the
+     * default) zero-downtime failover will only occur between origins within the same
+     * pool. See `session_affinity_attributes` for control over when sessions are
+     * broken or reassigned.
+     */
+    failover_across_pools?: boolean;
+}
 /**
  * WNAM: Western North America, ENAM: Eastern North America, WEU: Western Europe,
  * EEU: Eastern Europe, NSAM: Northern South America, SSAM: Southern South America,
@@ -67,10 +86,22 @@ export interface AdaptiveRouting {
  * regions (ENTERPRISE customers only).
  */
 export type CheckRegion = 'WNAM' | 'ENAM' | 'WEU' | 'EEU' | 'NSAM' | 'SSAM' | 'OC' | 'ME' | 'NAF' | 'SAF' | 'SAS' | 'SEAS' | 'NEAS' | 'ALL_REGIONS';
+/**
+ * WNAM: Western North America, ENAM: Eastern North America, WEU: Western Europe,
+ * EEU: Eastern Europe, NSAM: Northern South America, SSAM: Southern South America,
+ * OC: Oceania, ME: Middle East, NAF: North Africa, SAF: South Africa, SAS:
+ * Southern Asia, SEAS: South East Asia, NEAS: North East Asia, ALL_REGIONS: all
+ * regions (ENTERPRISE customers only).
+ */
+export type CheckRegionParam = 'WNAM' | 'ENAM' | 'WEU' | 'EEU' | 'NSAM' | 'SSAM' | 'OC' | 'ME' | 'NAF' | 'SAF' | 'SAS' | 'SEAS' | 'NEAS' | 'ALL_REGIONS';
 /**
  * A pool ID.
  */
 export type DefaultPools = string;
+/**
+ * A pool ID.
+ */
+export type DefaultPoolsParam = string;
 /**
  * Filter options for a particular resource type (pool or origin). Use null to
  * reset.
@@ -86,6 +117,21 @@ export interface FilterOptions {
      */
     healthy?: boolean | null;
 }
+/**
+ * Filter options for a particular resource type (pool or origin). Use null to
+ * reset.
+ */
+export interface FilterOptionsParam {
+    /**
+     * If set true, disable notifications for this type of resource (pool or origin).
+     */
+    disable?: boolean;
+    /**
+     * If present, send notifications only for this health status (e.g. false for only
+     * DOWN events). Use null to reset (all events).
+     */
+    healthy?: boolean | null;
+}
 /**
  * The request header is used to pass additional information with an HTTP request.
  * Currently supported header is 'Host'.
@@ -97,7 +143,19 @@ export interface Header {
      */
     Host?: Array<Host>;
 }
+/**
+ * The request header is used to pass additional information with an HTTP request.
+ * Currently supported header is 'Host'.
+ */
+export interface HeaderParam {
+    /**
+     * The 'Host' header allows to override the hostname set in the HTTP request.
+     * Current support is 1 'Host' header override per origin.
+     */
+    Host?: Array<HostParam>;
+}
 export type Host = string;
+export type HostParam = string;
 export interface LoadBalancer {
     id?: string;
     /**
@@ -204,7 +262,7 @@ export interface LoadBalancer {
      *   `headers` in `session_affinity_attributes` for additional required
      *   configuration.
      */
-    session_affinity?: 'none' | 'cookie' | 'ip_cookie' | 'header' | '""';
+    session_affinity?: SessionAffinity;
     /**
      * Configures attributes for session affinity.
      */
@@ -246,7 +304,7 @@ export interface LoadBalancer {
      * - `""`: Will map to `"geo"` if you use
      *   `region_pools`/`country_pools`/`pop_pools` otherwise `"off"`.
      */
-    steering_policy?: 'off' | 'geo' | 'random' | 'dynamic_latency' | 'proximity' | 'least_outstanding_requests' | 'least_connections' | '""';
+    steering_policy?: SteeringPolicy;
     /**
      * 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.
@@ -280,6 +338,33 @@ export interface LoadShedding {
      */
     session_policy?: 'hash';
 }
+/**
+ * Configures load shedding policies and percentages for the pool.
+ */
+export interface LoadSheddingParam {
+    /**
+     * The percent of traffic to shed from the pool, according to the default policy.
+     * Applies to new sessions and traffic without session affinity.
+     */
+    default_percent?: number;
+    /**
+     * The default policy to use when load shedding. A random policy randomly sheds a
+     * given percent of requests. A hash policy computes a hash over the
+     * CF-Connecting-IP address and sheds all requests originating from a percent of
+     * IPs.
+     */
+    default_policy?: 'random' | 'hash';
+    /**
+     * The percent of existing sessions to shed from the pool, according to the session
+     * policy.
+     */
+    session_percent?: number;
+    /**
+     * Only the hash policy is supported for existing sessions (to avoid exponential
+     * decay).
+     */
+    session_policy?: 'hash';
+}
 /**
  * Controls location-based steering for non-proxied requests. See `steering_policy`
  * to learn how steering is affected.
@@ -305,6 +390,31 @@ export interface LocationStrategy {
      */
     prefer_ecs?: 'always' | 'never' | 'proximity' | 'geo';
 }
+/**
+ * Controls location-based steering for non-proxied requests. See `steering_policy`
+ * to learn how steering is affected.
+ */
+export interface LocationStrategyParam {
+    /**
+     * Determines the authoritative location when ECS is not preferred, does not exist
+     * in the request, or its GeoIP lookup is unsuccessful.
+     *
+     * - `"pop"`: Use the Cloudflare PoP location.
+     * - `"resolver_ip"`: Use the DNS resolver GeoIP location. If the GeoIP lookup is
+     *   unsuccessful, use the Cloudflare PoP location.
+     */
+    mode?: 'pop' | 'resolver_ip';
+    /**
+     * Whether the EDNS Client Subnet (ECS) GeoIP should be preferred as the
+     * authoritative location.
+     *
+     * - `"always"`: Always prefer ECS.
+     * - `"never"`: Never prefer ECS.
+     * - `"proximity"`: Prefer ECS only when `steering_policy="proximity"`.
+     * - `"geo"`: Prefer ECS only when `steering_policy="geo"`.
+     */
+    prefer_ecs?: 'always' | 'never' | 'proximity' | 'geo';
+}
 /**
  * Filter pool and origin health notifications by resource type or health status.
  * Use null to reset.
@@ -321,6 +431,22 @@ export interface NotificationFilter {
      */
     pool?: FilterOptions | null;
 }
+/**
+ * Filter pool and origin health notifications by resource type or health status.
+ * Use null to reset.
+ */
+export interface NotificationFilterParam {
+    /**
+     * Filter options for a particular resource type (pool or origin). Use null to
+     * reset.
+     */
+    origin?: FilterOptionsParam | null;
+    /**
+     * Filter options for a particular resource type (pool or origin). Use null to
+     * reset.
+     */
+    pool?: FilterOptionsParam | null;
+}
 export interface Origin {
     /**
      * The IP address (IPv4 or IPv6) of the origin, or its publicly addressable
@@ -366,6 +492,46 @@ export interface Origin {
      */
     weight?: number;
 }
+export interface OriginParam {
+    /**
+     * The IP address (IPv4 or IPv6) of the origin, or its publicly addressable
+     * hostname. Hostnames entered here should resolve directly to the origin, and not
+     * be a hostname proxied by Cloudflare. To set an internal/reserved address,
+     * virtual_network_id must also be set.
+     */
+    address?: string;
+    /**
+     * Whether to enable (the default) this origin within the pool. Disabled origins
+     * will not receive traffic and are excluded from health checks. The origin will
+     * only be disabled for the current pool.
+     */
+    enabled?: boolean;
+    /**
+     * The request header is used to pass additional information with an HTTP request.
+     * Currently supported header is 'Host'.
+     */
+    header?: HeaderParam;
+    /**
+     * A human-identifiable name for the origin.
+     */
+    name?: string;
+    /**
+     * The virtual network subnet ID the origin belongs in. Virtual network must also
+     * belong to the account.
+     */
+    virtual_network_id?: string;
+    /**
+     * The weight of this origin relative to other origins in the pool. Based on the
+     * configured weight the total traffic is distributed among origins within the
+     * pool.
+     *
+     * - `origin_steering.policy="least_outstanding_requests"`: Use weight to scale the
+     *   origin's outstanding requests.
+     * - `origin_steering.policy="least_connections"`: Use weight to scale the origin's
+     *   open connections.
+     */
+    weight?: number;
+}
 /**
  * Configures origin steering for the pool. Controls how origins are selected for
  * new sessions and traffic without session affinity.
@@ -388,6 +554,28 @@ export interface OriginSteering {
      */
     policy?: 'random' | 'hash' | 'least_outstanding_requests' | 'least_connections';
 }
+/**
+ * Configures origin steering for the pool. Controls how origins are selected for
+ * new sessions and traffic without session affinity.
+ */
+export interface OriginSteeringParam {
+    /**
+     * The type of origin steering policy to use.
+     *
+     * - `"random"`: Select an origin randomly.
+     * - `"hash"`: Select an origin by computing a hash over the CF-Connecting-IP
+     *   address.
+     * - `"least_outstanding_requests"`: Select an origin by taking into consideration
+     *   origin weights, as well as each origin's number of outstanding requests.
+     *   Origins with more pending requests are weighted proportionately less relative
+     *   to others.
+     * - `"least_connections"`: Select an origin by taking into consideration origin
+     *   weights, as well as each origin's number of open connections. Origins with
+     *   more open connections are weighted proportionately less relative to others.
+     *   Supported for HTTP/1 and HTTP/2 connections.
+     */
+    policy?: 'random' | 'hash' | 'least_outstanding_requests' | 'least_connections';
+}
 /**
  * Configures pool weights.
  *
@@ -410,6 +598,28 @@ export interface RandomSteering {
      */
     pool_weights?: unknown;
 }
+/**
+ * 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 scale each
+ *   pool's outstanding requests.
+ * - `steering_policy="least_connections"`: Use pool weights to scale each pool's
+ *   open connections.
+ */
+export interface RandomSteeringParam {
+    /**
+     * The default weight for pools in the load balancer that are not specified in the
+     * pool_weights map.
+     */
+    default_weight?: number;
+    /**
+     * A mapping of pool IDs to custom weights. The weight is relative to other pools
+     * in the load balancer.
+     */
+    pool_weights?: unknown;
+}
 /**
  * A rule object containing conditions and overrides for this load balancer to
  * evaluate.
@@ -563,7 +773,7 @@ export declare namespace Rules {
          *   `headers` in `session_affinity_attributes` for additional required
          *   configuration.
          */
-        session_affinity?: 'none' | 'cookie' | 'ip_cookie' | 'header' | '""';
+        session_affinity?: LoadBalancersAPI.SessionAffinity;
         /**
          * Configures attributes for session affinity.
          */
@@ -605,7 +815,7 @@ export declare namespace Rules {
          * - `""`: Will map to `"geo"` if you use
          *   `region_pools`/`country_pools`/`pop_pools` otherwise `"off"`.
          */
-        steering_policy?: 'off' | 'geo' | 'random' | 'dynamic_latency' | 'proximity' | 'least_outstanding_requests' | 'least_connections' | '""';
+        steering_policy?: LoadBalancersAPI.SteeringPolicy;
         /**
          * 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.
@@ -613,6 +823,261 @@ export declare namespace Rules {
         ttl?: number;
     }
 }
+/**
+ * A rule object containing conditions and overrides for this load balancer to
+ * evaluate.
+ */
+export interface RulesParam {
+    /**
+     * The condition expressions to evaluate. If the condition evaluates to true, the
+     * overrides or fixed_response in this rule will be applied. An empty condition is
+     * always true. For more details on condition expressions, please see
+     * https://developers.cloudflare.com/load-balancing/understand-basics/load-balancing-rules/expressions.
+     */
+    condition?: string;
+    /**
+     * Disable this specific rule. It will no longer be evaluated by this load
+     * balancer.
+     */
+    disabled?: boolean;
+    /**
+     * A collection of fields used to directly respond to the eyeball instead of
+     * routing to a pool. If a fixed_response is supplied the rule will be marked as
+     * terminates.
+     */
+    fixed_response?: RulesParam.FixedResponse;
+    /**
+     * Name of this rule. Only used for human readability.
+     */
+    name?: string;
+    /**
+     * A collection of overrides to apply to the load balancer when this rule's
+     * condition is true. All fields are optional.
+     */
+    overrides?: RulesParam.Overrides;
+    /**
+     * The order in which rules should be executed in relation to each other. Lower
+     * values are executed first. Values do not need to be sequential. If no value is
+     * provided for any rule the array order of the rules field will be used to assign
+     * a priority.
+     */
+    priority?: number;
+    /**
+     * If this rule's condition is true, this causes rule evaluation to stop after
+     * processing this rule.
+     */
+    terminates?: boolean;
+}
+export declare namespace RulesParam {
+    /**
+     * A collection of fields used to directly respond to the eyeball instead of
+     * routing to a pool. If a fixed_response is supplied the rule will be marked as
+     * terminates.
+     */
+    interface FixedResponse {
+        /**
+         * The http 'Content-Type' header to include in the response.
+         */
+        content_type?: string;
+        /**
+         * The http 'Location' header to include in the response.
+         */
+        location?: string;
+        /**
+         * Text to include as the http body.
+         */
+        message_body?: string;
+        /**
+         * The http status code to respond with.
+         */
+        status_code?: number;
+    }
+    /**
+     * A collection of overrides to apply to the load balancer when this rule's
+     * condition is true. All fields are optional.
+     */
+    interface Overrides {
+        /**
+         * 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-downtime failover occurs
+         * immediately when an origin becomes unavailable due to HTTP 521, 522, or 523
+         * response codes. If there is another healthy origin in the same pool, the request
+         * is retried once against this alternate origin.
+         */
+        adaptive_routing?: LoadBalancersAPI.AdaptiveRoutingParam;
+        /**
+         * 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 mapping if it exists else to
+         * default_pools.
+         */
+        country_pools?: unknown;
+        /**
+         * 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.
+         */
+        default_pools?: Array<LoadBalancersAPI.DefaultPoolsParam>;
+        /**
+         * The pool ID to use when all other pools are detected as unhealthy.
+         */
+        fallback_pool?: unknown;
+        /**
+         * Controls location-based steering for non-proxied requests. See `steering_policy`
+         * to learn how steering is affected.
+         */
+        location_strategy?: LoadBalancersAPI.LocationStrategyParam;
+        /**
+         * (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 the corresponding country_pool, then
+         * region_pool mapping if it exists else to default_pools.
+         */
+        pop_pools?: unknown;
+        /**
+         * 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 scale each
+         *   pool's outstanding requests.
+         * - `steering_policy="least_connections"`: Use pool weights to scale each pool's
+         *   open connections.
+         */
+        random_steering?: LoadBalancersAPI.RandomSteeringParam;
+        /**
+         * 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.
+         */
+        region_pools?: unknown;
+        /**
+         * Specifies the type of session affinity the load balancer should use unless
+         * specified as `"none"` or "" (default). The supported types are:
+         *
+         * - `"cookie"`: On the first request to a proxied load balancer, a cookie is
+         *   generated, encoding information of which origin the request will be forwarded
+         *   to. Subsequent requests, by the same client to the same load balancer, will be
+         *   sent to the origin server the cookie encodes, for the duration of the cookie
+         *   and as long as the origin server remains healthy. If the cookie has expired or
+         *   the origin server is unhealthy, then a new origin server is calculated and
+         *   used.
+         * - `"ip_cookie"`: Behaves the same as `"cookie"` except the initial origin
+         *   selection is stable and based on the client's ip address.
+         * - `"header"`: On the first request to a proxied load balancer, a session key
+         *   based on the configured HTTP headers (see
+         *   `session_affinity_attributes.headers`) is generated, encoding the request
+         *   headers used for storing in the load balancer session state which origin the
+         *   request will be forwarded to. Subsequent requests to the load balancer with
+         *   the same headers will be sent to the same origin server, for the duration of
+         *   the session and as long as the origin server remains healthy. If the session
+         *   has been idle for the duration of `session_affinity_ttl` seconds or the origin
+         *   server is unhealthy, then a new origin server is calculated and used. See
+         *   `headers` in `session_affinity_attributes` for additional required
+         *   configuration.
+         */
+        session_affinity?: LoadBalancersAPI.SessionAffinityParam;
+        /**
+         * Configures attributes for session affinity.
+         */
+        session_affinity_attributes?: LoadBalancersAPI.SessionAffinityAttributesParam;
+        /**
+         * 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 `session_affinity` policy are:
+         *
+         * - `"cookie"` / `"ip_cookie"`: The current default of 23 hours will be used
+         *   unless explicitly set. The accepted range of values is between [1800, 604800].
+         * - `"header"`: The current default of 1800 seconds will be used unless explicitly
+         *   set. The accepted range of values is between [30, 3600]. Note: With session
+         *   affinity by header, sessions only expire after they haven't been used for the
+         *   number of seconds specified.
+         */
+        session_affinity_ttl?: number;
+        /**
+         * 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 determined by
+         *   `location_strategy`.
+         * - `"random"`: Select a pool randomly.
+         * - `"dynamic_latency"`: Use round trip time to select the closest pool in
+         *   default_pools (requires pool health checks).
+         * - `"proximity"`: Use the pools' latitude and longitude to select the closest
+         *   pool using the Cloudflare PoP location for proxied requests or the location
+         *   determined by `location_strategy` for non-proxied requests.
+         * - `"least_outstanding_requests"`: Select a pool by taking into consideration
+         *   `random_steering` weights, as well as each pool's number of outstanding
+         *   requests. Pools with more pending requests are weighted proportionately less
+         *   relative to others.
+         * - `"least_connections"`: Select a pool by taking into consideration
+         *   `random_steering` weights, as well as each pool's number of open connections.
+         *   Pools with more open connections are weighted proportionately less relative to
+         *   others. Supported for HTTP/1 and HTTP/2 connections.
+         * - `""`: Will map to `"geo"` if you use
+         *   `region_pools`/`country_pools`/`pop_pools` otherwise `"off"`.
+         */
+        steering_policy?: LoadBalancersAPI.SteeringPolicyParam;
+        /**
+         * 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;
+    }
+}
+/**
+ * Specifies the type of session affinity the load balancer should use unless
+ * specified as `"none"` or "" (default). The supported types are:
+ *
+ * - `"cookie"`: On the first request to a proxied load balancer, a cookie is
+ *   generated, encoding information of which origin the request will be forwarded
+ *   to. Subsequent requests, by the same client to the same load balancer, will be
+ *   sent to the origin server the cookie encodes, for the duration of the cookie
+ *   and as long as the origin server remains healthy. If the cookie has expired or
+ *   the origin server is unhealthy, then a new origin server is calculated and
+ *   used.
+ * - `"ip_cookie"`: Behaves the same as `"cookie"` except the initial origin
+ *   selection is stable and based on the client's ip address.
+ * - `"header"`: On the first request to a proxied load balancer, a session key
+ *   based on the configured HTTP headers (see
+ *   `session_affinity_attributes.headers`) is generated, encoding the request
+ *   headers used for storing in the load balancer session state which origin the
+ *   request will be forwarded to. Subsequent requests to the load balancer with
+ *   the same headers will be sent to the same origin server, for the duration of
+ *   the session and as long as the origin server remains healthy. If the session
+ *   has been idle for the duration of `session_affinity_ttl` seconds or the origin
+ *   server is unhealthy, then a new origin server is calculated and used. See
+ *   `headers` in `session_affinity_attributes` for additional required
+ *   configuration.
+ */
+export type SessionAffinity = 'none' | 'cookie' | 'ip_cookie' | 'header' | '""';
+/**
+ * Specifies the type of session affinity the load balancer should use unless
+ * specified as `"none"` or "" (default). The supported types are:
+ *
+ * - `"cookie"`: On the first request to a proxied load balancer, a cookie is
+ *   generated, encoding information of which origin the request will be forwarded
+ *   to. Subsequent requests, by the same client to the same load balancer, will be
+ *   sent to the origin server the cookie encodes, for the duration of the cookie
+ *   and as long as the origin server remains healthy. If the cookie has expired or
+ *   the origin server is unhealthy, then a new origin server is calculated and
+ *   used.
+ * - `"ip_cookie"`: Behaves the same as `"cookie"` except the initial origin
+ *   selection is stable and based on the client's ip address.
+ * - `"header"`: On the first request to a proxied load balancer, a session key
+ *   based on the configured HTTP headers (see
+ *   `session_affinity_attributes.headers`) is generated, encoding the request
+ *   headers used for storing in the load balancer session state which origin the
+ *   request will be forwarded to. Subsequent requests to the load balancer with
+ *   the same headers will be sent to the same origin server, for the duration of
+ *   the session and as long as the origin server remains healthy. If the session
+ *   has been idle for the duration of `session_affinity_ttl` seconds or the origin
+ *   server is unhealthy, then a new origin server is calculated and used. See
+ *   `headers` in `session_affinity_attributes` for additional required
+ *   configuration.
+ */
+export type SessionAffinityParam = 'none' | 'cookie' | 'ip_cookie' | 'header' | '""';
 /**
  * Configures attributes for session affinity.
  */
@@ -674,6 +1139,117 @@ export interface SessionAffinityAttributes {
      */
     zero_downtime_failover?: 'none' | 'temporary' | 'sticky';
 }
+/**
+ * Configures attributes for session affinity.
+ */
+export interface SessionAffinityAttributesParam {
+    /**
+     * Configures the drain duration in seconds. This field is only used when session
+     * affinity is enabled on the load balancer.
+     */
+    drain_duration?: number;
+    /**
+     * Configures the names of HTTP headers to base session affinity on when header
+     * `session_affinity` is enabled. At least one HTTP header name must be provided.
+     * To specify the exact cookies to be used, include an item in the following
+     * format: `"cookie:<cookie-name-1>,<cookie-name-2>"` (example) where everything
+     * after the colon is a comma-separated list of cookie names. Providing only
+     * `"cookie"` will result in all cookies being used. The default max number of HTTP
+     * header names that can be provided depends on your plan: 5 for Enterprise, 1 for
+     * all other plans.
+     */
+    headers?: Array<string>;
+    /**
+     * When header `session_affinity` is enabled, this option can be used to specify
+     * how HTTP headers on load balancing requests will be used. The supported values
+     * are:
+     *
+     * - `"true"`: Load balancing requests must contain _all_ of the HTTP headers
+     *   specified by the `headers` session affinity attribute, otherwise sessions
+     *   aren't created.
+     * - `"false"`: Load balancing requests must contain _at least one_ of the HTTP
+     *   headers specified by the `headers` session affinity attribute, otherwise
+     *   sessions aren't created.
+     */
+    require_all_headers?: boolean;
+    /**
+     * Configures the SameSite attribute on session affinity cookie. Value "Auto" will
+     * be translated to "Lax" or "None" depending if Always Use HTTPS is enabled. Note:
+     * when using value "None", the secure attribute can not be set to "Never".
+     */
+    samesite?: 'Auto' | 'Lax' | 'None' | 'Strict';
+    /**
+     * Configures the Secure attribute on session affinity cookie. Value "Always"
+     * indicates the Secure attribute will be set in the Set-Cookie header, "Never"
+     * indicates the Secure attribute will not be set, and "Auto" will set the Secure
+     * attribute depending if Always Use HTTPS is enabled.
+     */
+    secure?: 'Auto' | 'Always' | 'Never';
+    /**
+     * Configures the zero-downtime failover between origins within a pool when session
+     * affinity is enabled. This feature is currently incompatible with Argo, Tiered
+     * Cache, and Bandwidth Alliance. The supported values are:
+     *
+     * - `"none"`: No failover takes place for sessions pinned to the origin (default).
+     * - `"temporary"`: Traffic will be sent to another other healthy origin until the
+     *   originally pinned origin is available; note that this can potentially result
+     *   in heavy origin flapping.
+     * - `"sticky"`: The session affinity cookie is updated and subsequent requests are
+     *   sent to the new origin. Note: Zero-downtime failover with sticky sessions is
+     *   currently not supported for session affinity by header.
+     */
+    zero_downtime_failover?: 'none' | 'temporary' | 'sticky';
+}
+/**
+ * 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 determined by
+ *   `location_strategy`.
+ * - `"random"`: Select a pool randomly.
+ * - `"dynamic_latency"`: Use round trip time to select the closest pool in
+ *   default_pools (requires pool health checks).
+ * - `"proximity"`: Use the pools' latitude and longitude to select the closest
+ *   pool using the Cloudflare PoP location for proxied requests or the location
+ *   determined by `location_strategy` for non-proxied requests.
+ * - `"least_outstanding_requests"`: Select a pool by taking into consideration
+ *   `random_steering` weights, as well as each pool's number of outstanding
+ *   requests. Pools with more pending requests are weighted proportionately less
+ *   relative to others.
+ * - `"least_connections"`: Select a pool by taking into consideration
+ *   `random_steering` weights, as well as each pool's number of open connections.
+ *   Pools with more open connections are weighted proportionately less relative to
+ *   others. Supported for HTTP/1 and HTTP/2 connections.
+ * - `""`: Will map to `"geo"` if you use
+ *   `region_pools`/`country_pools`/`pop_pools` otherwise `"off"`.
+ */
+export type SteeringPolicy = 'off' | 'geo' | 'random' | 'dynamic_latency' | 'proximity' | 'least_outstanding_requests' | 'least_connections' | '""';
+/**
+ * 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 determined by
+ *   `location_strategy`.
+ * - `"random"`: Select a pool randomly.
+ * - `"dynamic_latency"`: Use round trip time to select the closest pool in
+ *   default_pools (requires pool health checks).
+ * - `"proximity"`: Use the pools' latitude and longitude to select the closest
+ *   pool using the Cloudflare PoP location for proxied requests or the location
+ *   determined by `location_strategy` for non-proxied requests.
+ * - `"least_outstanding_requests"`: Select a pool by taking into consideration
+ *   `random_steering` weights, as well as each pool's number of outstanding
+ *   requests. Pools with more pending requests are weighted proportionately less
+ *   relative to others.
+ * - `"least_connections"`: Select a pool by taking into consideration
+ *   `random_steering` weights, as well as each pool's number of open connections.
+ *   Pools with more open connections are weighted proportionately less relative to
+ *   others. Supported for HTTP/1 and HTTP/2 connections.
+ * - `""`: Will map to `"geo"` if you use
+ *   `region_pools`/`country_pools`/`pop_pools` otherwise `"off"`.
+ */
+export type SteeringPolicyParam = 'off' | 'geo' | 'random' | 'dynamic_latency' | 'proximity' | 'least_outstanding_requests' | 'least_connections' | '""';
 export interface LoadBalancerDeleteResponse {
     id?: string;
 }
@@ -687,7 +1263,7 @@ export interface LoadBalancerCreateParams {
      * here are used by default, or when region_pools are not configured for a given
      * region.
      */
-    default_pools: Array<DefaultPools>;
+    default_pools: Array<DefaultPoolsParam>;
     /**
      * Body param: The pool ID to use when all other pools are detected as unhealthy.
      */
@@ -706,7 +1282,7 @@ export interface LoadBalancerCreateParams {
      * response codes. If there is another healthy origin in the same pool, the request
      * is retried once against this alternate origin.
      */
-    adaptive_routing?: AdaptiveRouting;
+    adaptive_routing?: AdaptiveRoutingParam;
     /**
      * 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
@@ -722,7 +1298,7 @@ export interface LoadBalancerCreateParams {
      * Body param: Controls location-based steering for non-proxied requests. See
      * `steering_policy` to learn how steering is affected.
      */
-    location_strategy?: LocationStrategy;
+    location_strategy?: LocationStrategyParam;
     /**
      * 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
@@ -745,7 +1321,7 @@ export interface LoadBalancerCreateParams {
      * - `steering_policy="least_connections"`: Use pool weights to scale each pool's
      *   open connections.
      */
-    random_steering?: RandomSteering;
+    random_steering?: RandomSteeringParam;
     /**
      * 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
@@ -756,7 +1332,7 @@ export interface LoadBalancerCreateParams {
      * Body param: BETA Field Not General Access: A list of rules for this load
      * balancer to execute.
      */
-    rules?: Array<Rules>;
+    rules?: Array<RulesParam>;
     /**
      * Body param: Specifies the type of session affinity the load balancer should use
      * unless specified as `"none"` or "" (default). The supported types are:
@@ -782,11 +1358,11 @@ export interface LoadBalancerCreateParams {
      *   `headers` in `session_affinity_attributes` for additional required
      *   configuration.
      */
-    session_affinity?: 'none' | 'cookie' | 'ip_cookie' | 'header' | '""';
+    session_affinity?: SessionAffinityParam;
     /**
      * Body param: Configures attributes for session affinity.
      */
-    session_affinity_attributes?: SessionAffinityAttributes;
+    session_affinity_attributes?: SessionAffinityAttributesParam;
     /**
      * 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
@@ -825,7 +1401,7 @@ export interface LoadBalancerCreateParams {
      * - `""`: Will map to `"geo"` if you use
      *   `region_pools`/`country_pools`/`pop_pools` otherwise `"off"`.
      */
-    steering_policy?: 'off' | 'geo' | 'random' | 'dynamic_latency' | 'proximity' | 'least_outstanding_requests' | 'least_connections' | '""';
+    steering_policy?: SteeringPolicyParam;
     /**
      * 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
@@ -843,7 +1419,7 @@ export interface LoadBalancerUpdateParams {
      * here are used by default, or when region_pools are not configured for a given
      * region.
      */
-    default_pools: Array<DefaultPools>;
+    default_pools: Array<DefaultPoolsParam>;
     /**
      * Body param: The pool ID to use when all other pools are detected as unhealthy.
      */
@@ -862,7 +1438,7 @@ export interface LoadBalancerUpdateParams {
      * response codes. If there is another healthy origin in the same pool, the request
      * is retried once against this alternate origin.
      */
-    adaptive_routing?: AdaptiveRouting;
+    adaptive_routing?: AdaptiveRoutingParam;
     /**
      * 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
@@ -882,7 +1458,7 @@ export interface LoadBalancerUpdateParams {
      * Body param: Controls location-based steering for non-proxied requests. See
      * `steering_policy` to learn how steering is affected.
      */
-    location_strategy?: LocationStrategy;
+    location_strategy?: LocationStrategyParam;
     /**
      * 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
@@ -905,7 +1481,7 @@ export interface LoadBalancerUpdateParams {
      * - `steering_policy="least_connections"`: Use pool weights to scale each pool's
      *   open connections.
      */
-    random_steering?: RandomSteering;
+    random_steering?: RandomSteeringParam;
     /**
      * 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
@@ -916,7 +1492,7 @@ export interface LoadBalancerUpdateParams {
      * Body param: BETA Field Not General Access: A list of rules for this load
      * balancer to execute.
      */
-    rules?: Array<Rules>;
+    rules?: Array<RulesParam>;
     /**
      * Body param: Specifies the type of session affinity the load balancer should use
      * unless specified as `"none"` or "" (default). The supported types are:
@@ -942,11 +1518,11 @@ export interface LoadBalancerUpdateParams {
      *   `headers` in `session_affinity_attributes` for additional required
      *   configuration.
      */
-    session_affinity?: 'none' | 'cookie' | 'ip_cookie' | 'header' | '""';
+    session_affinity?: SessionAffinityParam;
     /**
      * Body param: Configures attributes for session affinity.
      */
-    session_affinity_attributes?: SessionAffinityAttributes;
+    session_affinity_attributes?: SessionAffinityAttributesParam;
     /**
      * 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
@@ -985,7 +1561,7 @@ export interface LoadBalancerUpdateParams {
      * - `""`: Will map to `"geo"` if you use
      *   `region_pools`/`country_pools`/`pop_pools` otherwise `"off"`.
      */
-    steering_policy?: 'off' | 'geo' | 'random' | 'dynamic_latency' | 'proximity' | 'least_outstanding_requests' | 'least_connections' | '""';
+    steering_policy?: SteeringPolicyParam;
     /**
      * 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
@@ -997,14 +1573,7 @@ export interface LoadBalancerListParams {
     zone_id: string;
 }
 export interface LoadBalancerDeleteParams {
-    /**
-     * Path param:
-     */
     zone_id: string;
-    /**
-     * Body param:
-     */
-    body: unknown;
 }
 export interface LoadBalancerEditParams {
     /**
@@ -1019,7 +1588,7 @@ export interface LoadBalancerEditParams {
      * response codes. If there is another healthy origin in the same pool, the request
      * is retried once against this alternate origin.
      */
-    adaptive_routing?: AdaptiveRouting;
+    adaptive_routing?: AdaptiveRoutingParam;
     /**
      * 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
@@ -1032,7 +1601,7 @@ export interface LoadBalancerEditParams {
      * here are used by default, or when region_pools are not configured for a given
      * region.
      */
-    default_pools?: Array<DefaultPools>;
+    default_pools?: Array<DefaultPoolsParam>;
     /**
      * Body param: Object description.
      */
@@ -1049,7 +1618,7 @@ export interface LoadBalancerEditParams {
      * Body param: Controls location-based steering for non-proxied requests. See
      * `steering_policy` to learn how steering is affected.
      */
-    location_strategy?: LocationStrategy;
+    location_strategy?: LocationStrategyParam;
     /**
      * 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
@@ -1078,7 +1647,7 @@ export interface LoadBalancerEditParams {
      * - `steering_policy="least_connections"`: Use pool weights to scale each pool's
      *   open connections.
      */
-    random_steering?: RandomSteering;
+    random_steering?: RandomSteeringParam;
     /**
      * 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
@@ -1089,7 +1658,7 @@ export interface LoadBalancerEditParams {
      * Body param: BETA Field Not General Access: A list of rules for this load
      * balancer to execute.
      */
-    rules?: Array<Rules>;
+    rules?: Array<RulesParam>;
     /**
      * Body param: Specifies the type of session affinity the load balancer should use
      * unless specified as `"none"` or "" (default). The supported types are:
@@ -1115,11 +1684,11 @@ export interface LoadBalancerEditParams {
      *   `headers` in `session_affinity_attributes` for additional required
      *   configuration.
      */
-    session_affinity?: 'none' | 'cookie' | 'ip_cookie' | 'header' | '""';
+    session_affinity?: SessionAffinityParam;
     /**
      * Body param: Configures attributes for session affinity.
      */
-    session_affinity_attributes?: SessionAffinityAttributes;
+    session_affinity_attributes?: SessionAffinityAttributesParam;
     /**
      * 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
@@ -1158,7 +1727,7 @@ export interface LoadBalancerEditParams {
      * - `""`: Will map to `"geo"` if you use
      *   `region_pools`/`country_pools`/`pop_pools` otherwise `"off"`.
      */
-    steering_policy?: 'off' | 'geo' | 'random' | 'dynamic_latency' | 'proximity' | 'least_outstanding_requests' | 'least_connections' | '""';
+    steering_policy?: SteeringPolicyParam;
     /**
      * 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