cloudflare 3.0.0 → 3.2.0

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

@@ -109,6 +109,164 @@ export class LoadBalancers extends APIResource {
 
 export class LoadBalancersSinglePage extends SinglePage<LoadBalancer> {}
 
+/**
+ * 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 AdaptiveRouting {
+  /**
+   * 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;
+}
+
+/**
+ * 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,
+ * 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 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.
+ */
+export interface FilterOptions {
+  /**
+   * If set true, disable notifications for this type of resource (pool or origin).
+   */
+  disable?: boolean;
+
+  /**
+   * If present, send notifications only for this health status (e.g. false for only
+   * DOWN events). Use null to reset (all events).
+   */
+  healthy?: boolean | null;
+}
+
+/**
+ * Filter options for a particular resource type (pool or origin). Use null to
+ * reset.
+ */
+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'.
+ */
+export interface Header {
+  /**
+   * The 'Host' header allows to override the hostname set in the HTTP request.
+   * Current support is 1 'Host' header override per origin.
+   */
+  Host?: Array<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;
 
@@ -120,7 +278,7 @@ export interface LoadBalancer {
    * response codes. If there is another healthy origin in the same pool, the request
    * is retried once against this alternate origin.
    */
-  adaptive_routing?: LoadBalancer.AdaptiveRouting;
+  adaptive_routing?: AdaptiveRouting;
 
   /**
    * A mapping of country codes to a list of pool IDs (ordered by their failover
@@ -136,7 +294,7 @@ export interface LoadBalancer {
    * 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<string>;
+  default_pools?: Array<DefaultPools>;
 
   /**
    * Object description.
@@ -157,7 +315,7 @@ export interface LoadBalancer {
    * Controls location-based steering for non-proxied requests. See `steering_policy`
    * to learn how steering is affected.
    */
-  location_strategy?: LoadBalancer.LocationStrategy;
+  location_strategy?: LocationStrategy;
 
   modified_on?: string;
 
@@ -191,7 +349,7 @@ export interface LoadBalancer {
    * - `steering_policy="least_connections"`: Use pool weights to scale each pool's
    *   open connections.
    */
-  random_steering?: LoadBalancer.RandomSteering;
+  random_steering?: RandomSteering;
 
   /**
    * A mapping of region codes to a list of pool IDs (ordered by their failover
@@ -204,7 +362,7 @@ export interface LoadBalancer {
    * BETA Field Not General Access: A list of rules for this load balancer to
    * execute.
    */
-  rules?: Array<LoadBalancer.Rule>;
+  rules?: Array<Rules>;
 
   /**
    * Specifies the type of session affinity the load balancer should use unless
@@ -231,12 +389,12 @@ 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.
    */
-  session_affinity_attributes?: LoadBalancer.SessionAffinityAttributes;
+  session_affinity_attributes?: SessionAffinityAttributes;
 
   /**
    * Time, in seconds, until a client's session expires after being created. Once the
@@ -276,15 +434,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
@@ -293,521 +443,1060 @@ export interface LoadBalancer {
   ttl?: number;
 }
 
-export namespace LoadBalancer {
+/**
+ * Configures load shedding policies and percentages for the pool.
+ */
+export interface LoadShedding {
   /**
-   * 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.
+   * The percent of traffic to shed from the pool, according to the default policy.
+   * Applies to new sessions and traffic without session affinity.
    */
-  export interface AdaptiveRouting {
-    /**
-     * 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;
-  }
+  default_percent?: number;
 
   /**
-   * Controls location-based steering for non-proxied requests. See `steering_policy`
-   * to learn how steering is affected.
+   * 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.
    */
-  export interface LocationStrategy {
-    /**
-     * 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';
+  default_policy?: 'random' | 'hash';
 
-    /**
-     * 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';
-  }
+  /**
+   * The percent of existing sessions to shed from the pool, according to the session
+   * policy.
+   */
+  session_percent?: number;
 
   /**
-   * Configures pool weights.
+   * Only the hash policy is supported for existing sessions (to avoid exponential
+   * decay).
+   */
+  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.
+ */
+export interface LocationStrategy {
+  /**
+   * Determines the authoritative location when ECS is not preferred, does not exist
+   * in the request, or its GeoIP lookup is unsuccessful.
    *
-   * - `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
+   * - `"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';
+}
+
+/**
+ * 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.
+ */
+export interface NotificationFilter {
+  /**
+   * Filter options for a particular resource type (pool or origin). Use null to
+   * reset.
+   */
+  origin?: FilterOptions | null;
+
+  /**
+   * Filter options for a particular resource type (pool or origin). Use null to
+   * reset.
+   */
+  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
+   * hostname. Hostnames entered here should resolve directly to the origin, and not
+   * be a hostname proxied by Cloudflare. To set an internal/reserved address,
+   * virtual_network_id must also be set.
+   */
+  address?: string;
+
+  /**
+   * This field shows up only if the origin is disabled. This field is set with the
+   * time the origin was disabled.
+   */
+  disabled_at?: string;
+
+  /**
+   * Whether to enable (the default) this origin within the pool. Disabled origins
+   * will not receive traffic and are excluded from health checks. The origin will
+   * only be disabled for the current pool.
+   */
+  enabled?: boolean;
+
+  /**
+   * The request header is used to pass additional information with an HTTP request.
+   * Currently supported header is 'Host'.
+   */
+  header?: Header;
+
+  /**
+   * A human-identifiable name for the origin.
+   */
+  name?: string;
+
+  /**
+   * The virtual network subnet ID the origin belongs in. Virtual network must also
+   * belong to the account.
+   */
+  virtual_network_id?: string;
+
+  /**
+   * The weight of this origin relative to other origins in the pool. Based on the
+   * configured weight the total traffic is distributed among origins within the
+   * pool.
+   *
+   * - `origin_steering.policy="least_outstanding_requests"`: Use weight to scale the
+   *   origin's outstanding requests.
+   * - `origin_steering.policy="least_connections"`: Use weight to scale the origin's
+   *   open connections.
+   */
+  weight?: number;
+}
+
+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.
    */
-  export interface RandomSteering {
+  weight?: number;
+}
+
+/**
+ * Configures origin steering for the pool. Controls how origins are selected for
+ * new sessions and traffic without session affinity.
+ */
+export interface OriginSteering {
+  /**
+   * The type of origin steering policy to use.
+   *
+   * - `"random"`: Select an origin randomly.
+   * - `"hash"`: Select an origin by computing a hash over the CF-Connecting-IP
+   *   address.
+   * - `"least_outstanding_requests"`: Select an origin by taking into consideration
+   *   origin weights, as well as each origin's number of outstanding requests.
+   *   Origins with more pending requests are weighted proportionately less relative
+   *   to others.
+   * - `"least_connections"`: Select an origin by taking into consideration origin
+   *   weights, as well as each origin's number of open connections. Origins with
+   *   more open connections are weighted proportionately less relative to others.
+   *   Supported for HTTP/1 and HTTP/2 connections.
+   */
+  policy?: 'random' | 'hash' | 'least_outstanding_requests' | 'least_connections';
+}
+
+/**
+ * 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.
+ *
+ * - `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 RandomSteering {
+  /**
+   * 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;
+}
+
+/**
+ * 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.
+ */
+export interface Rules {
+  /**
+   * 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?: Rules.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?: Rules.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 namespace Rules {
+  /**
+   * 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.
+   */
+  export interface FixedResponse {
     /**
-     * The default weight for pools in the load balancer that are not specified in the
-     * pool_weights map.
+     * The http 'Content-Type' header to include in the response.
      */
-    default_weight?: number;
+    content_type?: string;
 
     /**
-     * A mapping of pool IDs to custom weights. The weight is relative to other pools
-     * in the load balancer.
+     * The http 'Location' header to include in the response.
      */
-    pool_weights?: unknown;
+    location?: string;
+
+    /**
+     * Text to include as the http body.
+     */
+    message_body?: string;
+
+    /**
+     * The http status code to respond with.
+     */
+    status_code?: number;
   }
 
   /**
-   * A rule object containing conditions and overrides for this load balancer to
-   * evaluate.
+   * A collection of overrides to apply to the load balancer when this rule's
+   * condition is true. All fields are optional.
    */
-  export interface Rule {
+  export 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.AdaptiveRouting;
+
+    /**
+     * 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;
+
     /**
-     * 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.
+     * 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.
      */
-    condition?: string;
+    default_pools?: Array<LoadBalancersAPI.DefaultPools>;
 
     /**
-     * Disable this specific rule. It will no longer be evaluated by this load
-     * balancer.
+     * The pool ID to use when all other pools are detected as unhealthy.
      */
-    disabled?: boolean;
+    fallback_pool?: unknown;
 
     /**
-     * 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.
+     * Controls location-based steering for non-proxied requests. See `steering_policy`
+     * to learn how steering is affected.
      */
-    fixed_response?: Rule.FixedResponse;
+    location_strategy?: LoadBalancersAPI.LocationStrategy;
 
     /**
-     * Name of this rule. Only used for human readability.
+     * (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.
      */
-    name?: string;
+    pop_pools?: unknown;
 
     /**
-     * A collection of overrides to apply to the load balancer when this rule's
-     * condition is true. All fields are optional.
+     * 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.
      */
-    overrides?: Rule.Overrides;
+    random_steering?: LoadBalancersAPI.RandomSteering;
 
     /**
-     * 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.
+     * 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.
      */
-    priority?: number;
+    region_pools?: unknown;
 
     /**
-     * If this rule's condition is true, this causes rule evaluation to stop after
-     * processing this rule.
+     * 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.SessionAffinity;
+
+    /**
+     * Configures attributes for session affinity.
+     */
+    session_affinity_attributes?: LoadBalancersAPI.SessionAffinityAttributes;
+
+    /**
+     * 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.
      */
-    terminates?: boolean;
+    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.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.
+     */
+    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;
 
-  export namespace Rule {
+  /**
+   * If this rule's condition is true, this causes rule evaluation to stop after
+   * processing this rule.
+   */
+  terminates?: boolean;
+}
+
+export 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.
+   */
+  export interface FixedResponse {
     /**
-     * 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.
+     * The http 'Content-Type' header to include in the response.
      */
-    export 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;
-    }
+    content_type?: string;
 
     /**
-     * A collection of overrides to apply to the load balancer when this rule's
-     * condition is true. All fields are optional.
+     * The http 'Location' header to include in the response.
      */
-    export 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?: Overrides.AdaptiveRouting;
-
-      /**
-       * 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<string>;
-
-      /**
-       * 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?: Overrides.LocationStrategy;
-
-      /**
-       * (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?: Overrides.RandomSteering;
-
-      /**
-       * 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?: 'none' | 'cookie' | 'ip_cookie' | 'header' | '""';
-
-      /**
-       * Configures attributes for session affinity.
-       */
-      session_affinity_attributes?: Overrides.SessionAffinityAttributes;
-
-      /**
-       * 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?:
-        | 'off'
-        | 'geo'
-        | 'random'
-        | 'dynamic_latency'
-        | 'proximity'
-        | 'least_outstanding_requests'
-        | 'least_connections'
-        | '""';
-
-      /**
-       * 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 namespace 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.
-       */
-      export interface AdaptiveRouting {
-        /**
-         * 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;
-      }
-
-      /**
-       * Controls location-based steering for non-proxied requests. See `steering_policy`
-       * to learn how steering is affected.
-       */
-      export interface LocationStrategy {
-        /**
-         * 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';
-      }
-
-      /**
-       * 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 RandomSteering {
-        /**
-         * 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;
-      }
-
-      /**
-       * Configures attributes for session affinity.
-       */
-      export interface SessionAffinityAttributes {
-        /**
-         * 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';
-      }
-    }
+    location?: string;
+
+    /**
+     * Text to include as the http body.
+     */
+    message_body?: string;
+
+    /**
+     * The http status code to respond with.
+     */
+    status_code?: number;
   }
 
   /**
-   * Configures attributes for session affinity.
+   * A collection of overrides to apply to the load balancer when this rule's
+   * condition is true. All fields are optional.
    */
-  export interface SessionAffinityAttributes {
+  export interface Overrides {
     /**
-     * Configures the drain duration in seconds. This field is only used when session
-     * affinity is enabled on the load balancer.
+     * 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.
      */
-    drain_duration?: number;
+    adaptive_routing?: LoadBalancersAPI.AdaptiveRoutingParam;
 
     /**
-     * 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.
+     * 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.
      */
-    headers?: Array<string>;
+    country_pools?: unknown;
 
     /**
-     * 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.
+     * 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.
      */
-    require_all_headers?: boolean;
+    location_strategy?: LoadBalancersAPI.LocationStrategyParam;
 
     /**
-     * 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".
+     * (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.
      */
-    samesite?: 'Auto' | 'Lax' | 'None' | 'Strict';
+    pop_pools?: unknown;
 
     /**
-     * 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.
+     * 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.
      */
-    secure?: 'Auto' | 'Always' | 'Never';
+    region_pools?: unknown;
 
     /**
-     * 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:
+     * Specifies the type of session affinity the load balancer should use unless
+     * specified as `"none"` or "" (default). The supported types 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.
+     * - `"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.
      */
-    zero_downtime_failover?: 'none' | 'temporary' | 'sticky';
+    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.
+ */
+export interface SessionAffinityAttributes {
+  /**
+   * 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';
+}
+
+/**
+ * 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;
 }
@@ -823,7 +1512,7 @@ export interface LoadBalancerCreateParams {
    * here are used by default, or when region_pools are not configured for a given
    * region.
    */
-  default_pools: Array<string>;
+  default_pools: Array<DefaultPoolsParam>;
 
   /**
    * Body param: The pool ID to use when all other pools are detected as unhealthy.
@@ -845,7 +1534,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?: LoadBalancerCreateParams.AdaptiveRouting;
+  adaptive_routing?: AdaptiveRoutingParam;
 
   /**
    * Body param: A mapping of country codes to a list of pool IDs (ordered by their
@@ -864,7 +1553,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?: LoadBalancerCreateParams.LocationStrategy;
+  location_strategy?: LocationStrategyParam;
 
   /**
    * Body param: (Enterprise only): A mapping of Cloudflare PoP identifiers to a list
@@ -890,7 +1579,7 @@ export interface LoadBalancerCreateParams {
    * - `steering_policy="least_connections"`: Use pool weights to scale each pool's
    *   open connections.
    */
-  random_steering?: LoadBalancerCreateParams.RandomSteering;
+  random_steering?: RandomSteeringParam;
 
   /**
    * Body param: A mapping of region codes to a list of pool IDs (ordered by their
@@ -903,7 +1592,7 @@ export interface LoadBalancerCreateParams {
    * Body param: BETA Field Not General Access: A list of rules for this load
    * balancer to execute.
    */
-  rules?: Array<LoadBalancerCreateParams.Rule>;
+  rules?: Array<RulesParam>;
 
   /**
    * Body param: Specifies the type of session affinity the load balancer should use
@@ -928,585 +1617,62 @@ export interface LoadBalancerCreateParams {
    *   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?: 'none' | 'cookie' | 'ip_cookie' | 'header' | '""';
-
-  /**
-   * Body param: Configures attributes for session affinity.
-   */
-  session_affinity_attributes?: LoadBalancerCreateParams.SessionAffinityAttributes;
-
-  /**
-   * 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 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;
-
-  /**
-   * 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` 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?:
-    | '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 namespace LoadBalancerCreateParams {
-  /**
-   * 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 AdaptiveRouting {
-    /**
-     * 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;
-  }
-
-  /**
-   * Controls location-based steering for non-proxied requests. See `steering_policy`
-   * to learn how steering is affected.
-   */
-  export interface LocationStrategy {
-    /**
-     * 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';
-  }
-
-  /**
-   * 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 RandomSteering {
-    /**
-     * 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.
-   */
-  export interface Rule {
-    /**
-     * 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?: Rule.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?: Rule.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 namespace Rule {
-    /**
-     * 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.
-     */
-    export 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.
-     */
-    export 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?: Overrides.AdaptiveRouting;
-
-      /**
-       * 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<string>;
-
-      /**
-       * 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?: Overrides.LocationStrategy;
-
-      /**
-       * (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?: Overrides.RandomSteering;
-
-      /**
-       * 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?: 'none' | 'cookie' | 'ip_cookie' | 'header' | '""';
-
-      /**
-       * Configures attributes for session affinity.
-       */
-      session_affinity_attributes?: Overrides.SessionAffinityAttributes;
-
-      /**
-       * 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?:
-        | 'off'
-        | 'geo'
-        | 'random'
-        | 'dynamic_latency'
-        | 'proximity'
-        | 'least_outstanding_requests'
-        | 'least_connections'
-        | '""';
-
-      /**
-       * 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 namespace 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.
-       */
-      export interface AdaptiveRouting {
-        /**
-         * 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;
-      }
-
-      /**
-       * Controls location-based steering for non-proxied requests. See `steering_policy`
-       * to learn how steering is affected.
-       */
-      export interface LocationStrategy {
-        /**
-         * 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';
-      }
-
-      /**
-       * 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 RandomSteering {
-        /**
-         * 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;
-      }
-
-      /**
-       * Configures attributes for session affinity.
-       */
-      export interface SessionAffinityAttributes {
-        /**
-         * 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';
-      }
-    }
-  }
-
-  /**
-   * Configures attributes for session affinity.
-   */
-  export interface SessionAffinityAttributes {
-    /**
-     * 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>;
+   *   configuration.
+   */
+  session_affinity?: SessionAffinityParam;
 
-    /**
-     * 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;
+  /**
+   * Body param: Configures attributes for session affinity.
+   */
+  session_affinity_attributes?: SessionAffinityAttributesParam;
 
-    /**
-     * 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';
+  /**
+   * 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 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;
 
-    /**
-     * 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';
+  /**
+   * 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` 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?: SteeringPolicyParam;
 
-    /**
-     * 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';
-  }
+  /**
+   * 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 interface LoadBalancerUpdateParams {
@@ -1520,7 +1686,7 @@ export interface LoadBalancerUpdateParams {
    * here are used by default, or when region_pools are not configured for a given
    * region.
    */
-  default_pools: Array<string>;
+  default_pools: Array<DefaultPoolsParam>;
 
   /**
    * Body param: The pool ID to use when all other pools are detected as unhealthy.
@@ -1542,7 +1708,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?: LoadBalancerUpdateParams.AdaptiveRouting;
+  adaptive_routing?: AdaptiveRoutingParam;
 
   /**
    * Body param: A mapping of country codes to a list of pool IDs (ordered by their
@@ -1566,7 +1732,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?: LoadBalancerUpdateParams.LocationStrategy;
+  location_strategy?: LocationStrategyParam;
 
   /**
    * Body param: (Enterprise only): A mapping of Cloudflare PoP identifiers to a list
@@ -1592,7 +1758,7 @@ export interface LoadBalancerUpdateParams {
    * - `steering_policy="least_connections"`: Use pool weights to scale each pool's
    *   open connections.
    */
-  random_steering?: LoadBalancerUpdateParams.RandomSteering;
+  random_steering?: RandomSteeringParam;
 
   /**
    * Body param: A mapping of region codes to a list of pool IDs (ordered by their
@@ -1605,7 +1771,7 @@ export interface LoadBalancerUpdateParams {
    * Body param: BETA Field Not General Access: A list of rules for this load
    * balancer to execute.
    */
-  rules?: Array<LoadBalancerUpdateParams.Rule>;
+  rules?: Array<RulesParam>;
 
   /**
    * Body param: Specifies the type of session affinity the load balancer should use
@@ -1632,12 +1798,12 @@ 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?: LoadBalancerUpdateParams.SessionAffinityAttributes;
+  session_affinity_attributes?: SessionAffinityAttributesParam;
 
   /**
    * Body param: Time, in seconds, until a client's session expires after being
@@ -1678,15 +1844,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
@@ -1696,521 +1854,6 @@ export interface LoadBalancerUpdateParams {
   ttl?: number;
 }
 
-export namespace LoadBalancerUpdateParams {
-  /**
-   * 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 AdaptiveRouting {
-    /**
-     * 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;
-  }
-
-  /**
-   * Controls location-based steering for non-proxied requests. See `steering_policy`
-   * to learn how steering is affected.
-   */
-  export interface LocationStrategy {
-    /**
-     * 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';
-  }
-
-  /**
-   * 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 RandomSteering {
-    /**
-     * 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.
-   */
-  export interface Rule {
-    /**
-     * 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?: Rule.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?: Rule.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 namespace Rule {
-    /**
-     * 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.
-     */
-    export 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.
-     */
-    export 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?: Overrides.AdaptiveRouting;
-
-      /**
-       * 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<string>;
-
-      /**
-       * 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?: Overrides.LocationStrategy;
-
-      /**
-       * (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?: Overrides.RandomSteering;
-
-      /**
-       * 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?: 'none' | 'cookie' | 'ip_cookie' | 'header' | '""';
-
-      /**
-       * Configures attributes for session affinity.
-       */
-      session_affinity_attributes?: Overrides.SessionAffinityAttributes;
-
-      /**
-       * 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?:
-        | 'off'
-        | 'geo'
-        | 'random'
-        | 'dynamic_latency'
-        | 'proximity'
-        | 'least_outstanding_requests'
-        | 'least_connections'
-        | '""';
-
-      /**
-       * 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 namespace 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.
-       */
-      export interface AdaptiveRouting {
-        /**
-         * 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;
-      }
-
-      /**
-       * Controls location-based steering for non-proxied requests. See `steering_policy`
-       * to learn how steering is affected.
-       */
-      export interface LocationStrategy {
-        /**
-         * 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';
-      }
-
-      /**
-       * 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 RandomSteering {
-        /**
-         * 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;
-      }
-
-      /**
-       * Configures attributes for session affinity.
-       */
-      export interface SessionAffinityAttributes {
-        /**
-         * 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';
-      }
-    }
-  }
-
-  /**
-   * Configures attributes for session affinity.
-   */
-  export interface SessionAffinityAttributes {
-    /**
-     * 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';
-  }
-}
-
 export interface LoadBalancerListParams {
   zone_id: string;
 }
@@ -2233,7 +1876,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?: LoadBalancerEditParams.AdaptiveRouting;
+  adaptive_routing?: AdaptiveRoutingParam;
 
   /**
    * Body param: A mapping of country codes to a list of pool IDs (ordered by their
@@ -2248,7 +1891,7 @@ export interface LoadBalancerEditParams {
    * here are used by default, or when region_pools are not configured for a given
    * region.
    */
-  default_pools?: Array<string>;
+  default_pools?: Array<DefaultPoolsParam>;
 
   /**
    * Body param: Object description.
@@ -2269,7 +1912,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?: LoadBalancerEditParams.LocationStrategy;
+  location_strategy?: LocationStrategyParam;
 
   /**
    * Body param: The DNS hostname to associate with your Load Balancer. If this
@@ -2302,7 +1945,7 @@ export interface LoadBalancerEditParams {
    * - `steering_policy="least_connections"`: Use pool weights to scale each pool's
    *   open connections.
    */
-  random_steering?: LoadBalancerEditParams.RandomSteering;
+  random_steering?: RandomSteeringParam;
 
   /**
    * Body param: A mapping of region codes to a list of pool IDs (ordered by their
@@ -2315,7 +1958,7 @@ export interface LoadBalancerEditParams {
    * Body param: BETA Field Not General Access: A list of rules for this load
    * balancer to execute.
    */
-  rules?: Array<LoadBalancerEditParams.Rule>;
+  rules?: Array<RulesParam>;
 
   /**
    * Body param: Specifies the type of session affinity the load balancer should use
@@ -2342,12 +1985,12 @@ 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?: LoadBalancerEditParams.SessionAffinityAttributes;
+  session_affinity_attributes?: SessionAffinityAttributesParam;
 
   /**
    * Body param: Time, in seconds, until a client's session expires after being
@@ -2388,15 +2031,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
@@ -2406,537 +2041,15 @@ export interface LoadBalancerEditParams {
   ttl?: number;
 }
 
-export namespace LoadBalancerEditParams {
-  /**
-   * 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 AdaptiveRouting {
-    /**
-     * 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;
-  }
-
-  /**
-   * Controls location-based steering for non-proxied requests. See `steering_policy`
-   * to learn how steering is affected.
-   */
-  export interface LocationStrategy {
-    /**
-     * 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';
-  }
-
-  /**
-   * 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 RandomSteering {
-    /**
-     * 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.
-   */
-  export interface Rule {
-    /**
-     * 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?: Rule.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?: Rule.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 namespace Rule {
-    /**
-     * 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.
-     */
-    export 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.
-     */
-    export 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?: Overrides.AdaptiveRouting;
-
-      /**
-       * 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<string>;
-
-      /**
-       * 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?: Overrides.LocationStrategy;
-
-      /**
-       * (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?: Overrides.RandomSteering;
-
-      /**
-       * 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?: 'none' | 'cookie' | 'ip_cookie' | 'header' | '""';
-
-      /**
-       * Configures attributes for session affinity.
-       */
-      session_affinity_attributes?: Overrides.SessionAffinityAttributes;
-
-      /**
-       * 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?:
-        | 'off'
-        | 'geo'
-        | 'random'
-        | 'dynamic_latency'
-        | 'proximity'
-        | 'least_outstanding_requests'
-        | 'least_connections'
-        | '""';
-
-      /**
-       * 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 namespace 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.
-       */
-      export interface AdaptiveRouting {
-        /**
-         * 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;
-      }
-
-      /**
-       * Controls location-based steering for non-proxied requests. See `steering_policy`
-       * to learn how steering is affected.
-       */
-      export interface LocationStrategy {
-        /**
-         * 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';
-      }
-
-      /**
-       * 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 RandomSteering {
-        /**
-         * 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;
-      }
-
-      /**
-       * Configures attributes for session affinity.
-       */
-      export interface SessionAffinityAttributes {
-        /**
-         * 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';
-      }
-    }
-  }
-
-  /**
-   * Configures attributes for session affinity.
-   */
-  export interface SessionAffinityAttributes {
-    /**
-     * 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';
-  }
-}
-
 export interface LoadBalancerGetParams {
   zone_id: string;
 }
 
 export namespace LoadBalancers {
-  export import LoadBalancer = LoadBalancersAPI.LoadBalancer;
-  export import LoadBalancerDeleteResponse = LoadBalancersAPI.LoadBalancerDeleteResponse;
-  export import LoadBalancersSinglePage = LoadBalancersAPI.LoadBalancersSinglePage;
-  export import LoadBalancerCreateParams = LoadBalancersAPI.LoadBalancerCreateParams;
-  export import LoadBalancerUpdateParams = LoadBalancersAPI.LoadBalancerUpdateParams;
-  export import LoadBalancerListParams = LoadBalancersAPI.LoadBalancerListParams;
-  export import LoadBalancerDeleteParams = LoadBalancersAPI.LoadBalancerDeleteParams;
-  export import LoadBalancerEditParams = LoadBalancersAPI.LoadBalancerEditParams;
-  export import LoadBalancerGetParams = LoadBalancersAPI.LoadBalancerGetParams;
   export import Monitors = MonitorsAPI.Monitors;
+  export import Monitor = MonitorsAPI.Monitor;
   export import MonitorDeleteResponse = MonitorsAPI.MonitorDeleteResponse;
+  export import MonitorsSinglePage = MonitorsAPI.MonitorsSinglePage;
   export import MonitorCreateParams = MonitorsAPI.MonitorCreateParams;
   export import MonitorUpdateParams = MonitorsAPI.MonitorUpdateParams;
   export import MonitorListParams = MonitorsAPI.MonitorListParams;
@@ -2944,7 +2057,9 @@ export namespace LoadBalancers {
   export import MonitorEditParams = MonitorsAPI.MonitorEditParams;
   export import MonitorGetParams = MonitorsAPI.MonitorGetParams;
   export import Pools = PoolsAPI.Pools;
+  export import Pool = PoolsAPI.Pool;
   export import PoolDeleteResponse = PoolsAPI.PoolDeleteResponse;
+  export import PoolsSinglePage = PoolsAPI.PoolsSinglePage;
   export import PoolCreateParams = PoolsAPI.PoolCreateParams;
   export import PoolUpdateParams = PoolsAPI.PoolUpdateParams;
   export import PoolListParams = PoolsAPI.PoolListParams;
@@ -2952,6 +2067,7 @@ export namespace LoadBalancers {
   export import PoolEditParams = PoolsAPI.PoolEditParams;
   export import PoolGetParams = PoolsAPI.PoolGetParams;
   export import Previews = PreviewsAPI.Previews;
+  export import PreviewGetResponse = PreviewsAPI.PreviewGetResponse;
   export import PreviewGetParams = PreviewsAPI.PreviewGetParams;
   export import Regions = RegionsAPI.Regions;
   export import RegionListResponse = RegionsAPI.RegionListResponse;