cloudflare 4.4.1 → 5.0.0

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

@@ -243,7 +243,9 @@ export interface LoadBalancer {
      * back to using the corresponding region_pool mapping if it exists else to
      * default_pools.
      */
-    country_pools?: Record<string, Array<string>>;
+    country_pools?: {
+        [key: string]: Array<string>;
+    };
     created_on?: string;
     /**
      * A list of pool IDs ordered by their failover priority. Pools defined here are
@@ -279,12 +281,14 @@ export interface LoadBalancer {
      */
     networks?: Array<string>;
     /**
-     * (Enterprise only): A mapping of Cloudflare PoP identifiers to a list of pool IDs
+     * 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?: Record<string, Array<string>>;
+    pop_pools?: {
+        [key: string]: Array<string>;
+    };
     /**
      * Whether the hostname should be gray clouded (false) or orange clouded (true).
      */
@@ -305,7 +309,9 @@ export interface LoadBalancer {
      * priority) for the given region. Any regions not explicitly defined will fall
      * back to using default_pools.
      */
-    region_pools?: Record<string, Array<string>>;
+    region_pools?: {
+        [key: string]: Array<string>;
+    };
     /**
      * BETA Field Not General Access: A list of rules for this load balancer to
      * execute.
@@ -313,28 +319,25 @@ export interface LoadBalancer {
     rules?: Array<Rules>;
     /**
      * Specifies the type of session affinity the load balancer should use unless
-     * specified as `"none"`. The supported types are:
-     *
-     * - `"cookie"`: On the first request to a proxied load balancer, a cookie is
-     *   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.
+     * specified as `"none"`. 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?: SessionAffinity;
     /**
@@ -344,14 +347,13 @@ export interface LoadBalancer {
     /**
      * 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.
+     * 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;
     /**
@@ -681,7 +683,9 @@ export interface RandomSteering {
      * A mapping of pool IDs to custom weights. The weight is relative to other pools
      * in the load balancer.
      */
-    pool_weights?: Record<string, number>;
+    pool_weights?: {
+        [key: string]: number;
+    };
 }
 /**
  * Configures pool weights.
@@ -703,7 +707,9 @@ export interface RandomSteeringParam {
      * A mapping of pool IDs to custom weights. The weight is relative to other pools
      * in the load balancer.
      */
-    pool_weights?: Record<string, number>;
+    pool_weights?: {
+        [key: string]: number;
+    };
 }
 /**
  * A rule object containing conditions and overrides for this load balancer to
@@ -794,7 +800,9 @@ export declare namespace Rules {
          * back to using the corresponding region_pool mapping if it exists else to
          * default_pools.
          */
-        country_pools?: Record<string, Array<string>>;
+        country_pools?: {
+            [key: string]: Array<string>;
+        };
         /**
          * 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.
@@ -810,12 +818,14 @@ export declare namespace Rules {
          */
         location_strategy?: LoadBalancersAPI.LocationStrategy;
         /**
-         * (Enterprise only): A mapping of Cloudflare PoP identifiers to a list of pool IDs
+         * 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?: Record<string, Array<string>>;
+        pop_pools?: {
+            [key: string]: Array<string>;
+        };
         /**
          * Configures pool weights.
          *
@@ -832,31 +842,30 @@ export declare namespace Rules {
          * priority) for the given region. Any regions not explicitly defined will fall
          * back to using default_pools.
          */
-        region_pools?: Record<string, Array<string>>;
+        region_pools?: {
+            [key: string]: Array<string>;
+        };
         /**
          * Specifies the type of session affinity the load balancer should use unless
-         * specified as `"none"`. The supported types are:
-         *
-         * - `"cookie"`: On the first request to a proxied load balancer, a cookie is
-         *   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.
+         * specified as `"none"`. 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;
         /**
@@ -866,14 +875,13 @@ export declare namespace Rules {
         /**
          * 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.
+         * 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;
         /**
@@ -997,7 +1005,9 @@ export declare namespace RulesParam {
          * back to using the corresponding region_pool mapping if it exists else to
          * default_pools.
          */
-        country_pools?: Record<string, Array<string>>;
+        country_pools?: {
+            [key: string]: Array<string>;
+        };
         /**
          * 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.
@@ -1013,12 +1023,14 @@ export declare namespace RulesParam {
          */
         location_strategy?: LoadBalancersAPI.LocationStrategyParam;
         /**
-         * (Enterprise only): A mapping of Cloudflare PoP identifiers to a list of pool IDs
+         * 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?: Record<string, Array<string>>;
+        pop_pools?: {
+            [key: string]: Array<string>;
+        };
         /**
          * Configures pool weights.
          *
@@ -1035,31 +1047,30 @@ export declare namespace RulesParam {
          * priority) for the given region. Any regions not explicitly defined will fall
          * back to using default_pools.
          */
-        region_pools?: Record<string, Array<string>>;
+        region_pools?: {
+            [key: string]: Array<string>;
+        };
         /**
          * Specifies the type of session affinity the load balancer should use unless
-         * specified as `"none"`. The supported types are:
-         *
-         * - `"cookie"`: On the first request to a proxied load balancer, a cookie is
-         *   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.
+         * specified as `"none"`. The supported types are: - `"cookie"`: On the first
+         * request to a proxied load balancer, a cookie is generated, encoding information
+         * of which origin the request will be forwarded to. Subsequent requests, by the
+         * same client to the same load balancer, will be sent to the origin server the
+         * cookie encodes, for the duration of the cookie and as long as the origin server
+         * remains healthy. If the cookie has expired or the origin server is unhealthy,
+         * then a new origin server is calculated and used. - `"ip_cookie"`: Behaves the
+         * same as `"cookie"` except the initial origin selection is stable and based on
+         * the client's ip address. - `"header"`: On the first request to a proxied load
+         * balancer, a session key based on the configured HTTP headers (see
+         * `session_affinity_attributes.headers`) is generated, encoding the request
+         * headers used for storing in the load balancer session state which origin the
+         * request will be forwarded to. Subsequent requests to the load balancer with the
+         * same headers will be sent to the same origin server, for the duration of the
+         * session and as long as the origin server remains healthy. If the session has
+         * been idle for the duration of `session_affinity_ttl` seconds or the origin
+         * server is unhealthy, then a new origin server is calculated and used. See
+         * `headers` in `session_affinity_attributes` for additional required
+         * configuration.
          */
         session_affinity?: LoadBalancersAPI.SessionAffinityParam;
         /**
@@ -1069,14 +1080,13 @@ export declare namespace RulesParam {
         /**
          * 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.
+         * 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;
         /**
@@ -1113,54 +1123,48 @@ export declare namespace RulesParam {
 }
 /**
  * Specifies the type of session affinity the load balancer should use unless
- * specified as `"none"`. The supported types are:
- *
- * - `"cookie"`: On the first request to a proxied load balancer, a cookie is
- *   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.
+ * specified as `"none"`. 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"`. 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.
+ * specified as `"none"`. 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';
 /**
@@ -1186,14 +1190,11 @@ export interface SessionAffinityAttributes {
     /**
      * 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.
+     * 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;
     /**
@@ -1212,15 +1213,13 @@ export interface SessionAffinityAttributes {
     /**
      * 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.
+     * 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';
 }
@@ -1247,14 +1246,11 @@ export interface SessionAffinityAttributesParam {
     /**
      * 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.
+     * 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;
     /**
@@ -1273,15 +1269,13 @@ export interface SessionAffinityAttributesParam {
     /**
      * 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.
+     * 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';
 }
@@ -1374,7 +1368,9 @@ export interface LoadBalancerCreateParams {
      * will fall back to using the corresponding region_pool mapping if it exists else
      * to default_pools.
      */
-    country_pools?: Record<string, Array<string>>;
+    country_pools?: {
+        [key: string]: Array<string>;
+    };
     /**
      * Body param: Object description.
      */
@@ -1389,12 +1385,14 @@ export interface LoadBalancerCreateParams {
      */
     networks?: Array<string>;
     /**
-     * Body param: (Enterprise only): A mapping of Cloudflare PoP identifiers to a list
+     * Body param: Enterprise only: A mapping of Cloudflare PoP identifiers to a list
      * of pool IDs (ordered by their failover priority) for the PoP (datacenter). Any
      * PoPs not explicitly defined will fall back to using the corresponding
      * country_pool, then region_pool mapping if it exists else to default_pools.
      */
-    pop_pools?: Record<string, Array<string>>;
+    pop_pools?: {
+        [key: string]: Array<string>;
+    };
     /**
      * Body param: Whether the hostname should be gray clouded (false) or orange
      * clouded (true).
@@ -1416,7 +1414,9 @@ export interface LoadBalancerCreateParams {
      * failover priority) for the given region. Any regions not explicitly defined will
      * fall back to using default_pools.
      */
-    region_pools?: Record<string, Array<string>>;
+    region_pools?: {
+        [key: string]: Array<string>;
+    };
     /**
      * Body param: BETA Field Not General Access: A list of rules for this load
      * balancer to execute.
@@ -1424,28 +1424,25 @@ export interface LoadBalancerCreateParams {
     rules?: Array<RulesParam>;
     /**
      * Body param: Specifies the type of session affinity the load balancer should use
-     * unless specified as `"none"`. The supported types are:
-     *
-     * - `"cookie"`: On the first request to a proxied load balancer, a 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.
+     * unless specified as `"none"`. 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?: SessionAffinityParam;
     /**
@@ -1456,14 +1453,12 @@ export interface LoadBalancerCreateParams {
      * 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.
+     * 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;
     /**
@@ -1534,7 +1529,9 @@ export interface LoadBalancerUpdateParams {
      * will fall back to using the corresponding region_pool mapping if it exists else
      * to default_pools.
      */
-    country_pools?: Record<string, Array<string>>;
+    country_pools?: {
+        [key: string]: Array<string>;
+    };
     /**
      * Body param: Object description.
      */
@@ -1553,12 +1550,14 @@ export interface LoadBalancerUpdateParams {
      */
     networks?: Array<string>;
     /**
-     * Body param: (Enterprise only): A mapping of Cloudflare PoP identifiers to a list
+     * Body param: Enterprise only: A mapping of Cloudflare PoP identifiers to a list
      * of pool IDs (ordered by their failover priority) for the PoP (datacenter). Any
      * PoPs not explicitly defined will fall back to using the corresponding
      * country_pool, then region_pool mapping if it exists else to default_pools.
      */
-    pop_pools?: Record<string, Array<string>>;
+    pop_pools?: {
+        [key: string]: Array<string>;
+    };
     /**
      * Body param: Whether the hostname should be gray clouded (false) or orange
      * clouded (true).
@@ -1580,7 +1579,9 @@ export interface LoadBalancerUpdateParams {
      * failover priority) for the given region. Any regions not explicitly defined will
      * fall back to using default_pools.
      */
-    region_pools?: Record<string, Array<string>>;
+    region_pools?: {
+        [key: string]: Array<string>;
+    };
     /**
      * Body param: BETA Field Not General Access: A list of rules for this load
      * balancer to execute.
@@ -1588,28 +1589,25 @@ export interface LoadBalancerUpdateParams {
     rules?: Array<RulesParam>;
     /**
      * Body param: Specifies the type of session affinity the load balancer should use
-     * unless specified as `"none"`. The supported types are:
-     *
-     * - `"cookie"`: On the first request to a proxied load balancer, a 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.
+     * unless specified as `"none"`. 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?: SessionAffinityParam;
     /**
@@ -1620,14 +1618,12 @@ export interface LoadBalancerUpdateParams {
      * 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.
+     * 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;
     /**
@@ -1688,7 +1684,9 @@ export interface LoadBalancerEditParams {
      * will fall back to using the corresponding region_pool mapping if it exists else
      * to default_pools.
      */
-    country_pools?: Record<string, Array<string>>;
+    country_pools?: {
+        [key: string]: Array<string>;
+    };
     /**
      * Body param: A list of pool IDs ordered by their failover priority. Pools defined
      * here are used by default, or when region_pools are not configured for a given
@@ -1719,12 +1717,14 @@ export interface LoadBalancerEditParams {
      */
     name?: string;
     /**
-     * Body param: (Enterprise only): A mapping of Cloudflare PoP identifiers to a list
+     * Body param: Enterprise only: A mapping of Cloudflare PoP identifiers to a list
      * of pool IDs (ordered by their failover priority) for the PoP (datacenter). Any
      * PoPs not explicitly defined will fall back to using the corresponding
      * country_pool, then region_pool mapping if it exists else to default_pools.
      */
-    pop_pools?: Record<string, Array<string>>;
+    pop_pools?: {
+        [key: string]: Array<string>;
+    };
     /**
      * Body param: Whether the hostname should be gray clouded (false) or orange
      * clouded (true).
@@ -1746,7 +1746,9 @@ export interface LoadBalancerEditParams {
      * failover priority) for the given region. Any regions not explicitly defined will
      * fall back to using default_pools.
      */
-    region_pools?: Record<string, Array<string>>;
+    region_pools?: {
+        [key: string]: Array<string>;
+    };
     /**
      * Body param: BETA Field Not General Access: A list of rules for this load
      * balancer to execute.
@@ -1754,28 +1756,25 @@ export interface LoadBalancerEditParams {
     rules?: Array<RulesParam>;
     /**
      * Body param: Specifies the type of session affinity the load balancer should use
-     * unless specified as `"none"`. The supported types are:
-     *
-     * - `"cookie"`: On the first request to a proxied load balancer, a 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.
+     * unless specified as `"none"`. 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?: SessionAffinityParam;
     /**
@@ -1786,14 +1785,12 @@ export interface LoadBalancerEditParams {
      * 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.
+     * 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;
     /**