@distilled.cloud/cloudflare 0.0.0-john

package/lib/services/load-balancers.js

@@ -0,0 +1,3181 @@
+/**
+ * Cloudflare LOAD-BALANCERS API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service load-balancers
+ */
+import * as stream from "effect/Stream";
+import * as Schema from "effect/Schema";
+import * as API from "../client/api.js";
+import * as T from "../traits.js";
+import {} from "../errors.js";
+export const GetLoadBalancerRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    loadBalancerId: Schema.String.pipe(T.HttpPath("loadBalancerId")),
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/zones/{zone_id}/load_balancers/{loadBalancerId}",
+}));
+export const GetLoadBalancerResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    adaptiveRouting: Schema.optional(Schema.Union([
+        Schema.Struct({
+            failoverAcrossPools: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        }).pipe(Schema.encodeKeys({ failoverAcrossPools: "failover_across_pools" })),
+        Schema.Null,
+    ])),
+    countryPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    defaultPools: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    fallbackPool: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    locationStrategy: Schema.optional(Schema.Union([
+        Schema.Struct({
+            mode: Schema.optional(Schema.Union([
+                Schema.Literals(["pop", "resolver_ip"]),
+                Schema.Null,
+            ])),
+            preferEcs: Schema.optional(Schema.Union([
+                Schema.Literals(["always", "never", "proximity", "geo"]),
+                Schema.Null,
+            ])),
+        }).pipe(Schema.encodeKeys({ mode: "mode", preferEcs: "prefer_ecs" })),
+        Schema.Null,
+    ])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    networks: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    popPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    proxied: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    randomSteering: Schema.optional(Schema.Union([
+        Schema.Struct({
+            defaultWeight: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            poolWeights: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            defaultWeight: "default_weight",
+            poolWeights: "pool_weights",
+        })),
+        Schema.Null,
+    ])),
+    regionPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    rules: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Struct({
+            condition: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            fixedResponse: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    contentType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    location: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    messageBody: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    statusCode: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    contentType: "content_type",
+                    location: "location",
+                    messageBody: "message_body",
+                    statusCode: "status_code",
+                })),
+                Schema.Null,
+            ])),
+            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            overrides: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    adaptiveRouting: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    countryPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                    defaultPools: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                    fallbackPool: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    locationStrategy: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    popPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                    randomSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    regionPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                    sessionAffinity: Schema.optional(Schema.Union([
+                        Schema.Literals([
+                            "none",
+                            "cookie",
+                            "ip_cookie",
+                            "header",
+                        ]),
+                        Schema.Null,
+                    ])),
+                    sessionAffinityAttributes: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    sessionAffinityTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                    steeringPolicy: Schema.optional(Schema.Union([
+                        Schema.Literals([
+                            "",
+                            "off",
+                            "geo",
+                            "random",
+                            "dynamic_latency",
+                            "proximity",
+                            "least_outstanding_requests",
+                            "least_connections",
+                        ]),
+                        Schema.Null,
+                    ])),
+                    ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    adaptiveRouting: "adaptive_routing",
+                    countryPools: "country_pools",
+                    defaultPools: "default_pools",
+                    fallbackPool: "fallback_pool",
+                    locationStrategy: "location_strategy",
+                    popPools: "pop_pools",
+                    randomSteering: "random_steering",
+                    regionPools: "region_pools",
+                    sessionAffinity: "session_affinity",
+                    sessionAffinityAttributes: "session_affinity_attributes",
+                    sessionAffinityTtl: "session_affinity_ttl",
+                    steeringPolicy: "steering_policy",
+                    ttl: "ttl",
+                })),
+                Schema.Null,
+            ])),
+            priority: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            terminates: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            condition: "condition",
+            disabled: "disabled",
+            fixedResponse: "fixed_response",
+            name: "name",
+            overrides: "overrides",
+            priority: "priority",
+            terminates: "terminates",
+        }))),
+        Schema.Null,
+    ])),
+    sessionAffinity: Schema.optional(Schema.Union([
+        Schema.Literals(["none", "cookie", "ip_cookie", "header"]),
+        Schema.Null,
+    ])),
+    sessionAffinityAttributes: Schema.optional(Schema.Union([
+        Schema.Struct({
+            drainDuration: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            headers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+            requireAllHeaders: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            samesite: Schema.optional(Schema.Union([
+                Schema.Literals(["Auto", "Lax", "None", "Strict"]),
+                Schema.Null,
+            ])),
+            secure: Schema.optional(Schema.Union([
+                Schema.Literals(["Auto", "Always", "Never"]),
+                Schema.Null,
+            ])),
+            zeroDowntimeFailover: Schema.optional(Schema.Union([
+                Schema.Literals(["none", "temporary", "sticky"]),
+                Schema.Null,
+            ])),
+        }).pipe(Schema.encodeKeys({
+            drainDuration: "drain_duration",
+            headers: "headers",
+            requireAllHeaders: "require_all_headers",
+            samesite: "samesite",
+            secure: "secure",
+            zeroDowntimeFailover: "zero_downtime_failover",
+        })),
+        Schema.Null,
+    ])),
+    sessionAffinityTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    steeringPolicy: Schema.optional(Schema.Union([
+        Schema.Literals([
+            "",
+            "off",
+            "geo",
+            "random",
+            "dynamic_latency",
+            "proximity",
+            "least_outstanding_requests",
+            "least_connections",
+        ]),
+        Schema.Null,
+    ])),
+    ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    zoneName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    adaptiveRouting: "adaptive_routing",
+    countryPools: "country_pools",
+    createdOn: "created_on",
+    defaultPools: "default_pools",
+    description: "description",
+    enabled: "enabled",
+    fallbackPool: "fallback_pool",
+    locationStrategy: "location_strategy",
+    modifiedOn: "modified_on",
+    name: "name",
+    networks: "networks",
+    popPools: "pop_pools",
+    proxied: "proxied",
+    randomSteering: "random_steering",
+    regionPools: "region_pools",
+    rules: "rules",
+    sessionAffinity: "session_affinity",
+    sessionAffinityAttributes: "session_affinity_attributes",
+    sessionAffinityTtl: "session_affinity_ttl",
+    steeringPolicy: "steering_policy",
+    ttl: "ttl",
+    zoneName: "zone_name",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getLoadBalancer = API.make(() => ({
+    input: GetLoadBalancerRequest,
+    output: GetLoadBalancerResponse,
+    errors: [],
+}));
+export const ListLoadBalancersRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({ method: "GET", path: "/zones/{zone_id}/load_balancers" }));
+export const ListLoadBalancersResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        adaptiveRouting: Schema.optional(Schema.Union([
+            Schema.Struct({
+                failoverAcrossPools: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                failoverAcrossPools: "failover_across_pools",
+            })),
+            Schema.Null,
+        ])),
+        countryPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+        createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        defaultPools: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+        description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        fallbackPool: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        locationStrategy: Schema.optional(Schema.Union([
+            Schema.Struct({
+                mode: Schema.optional(Schema.Union([
+                    Schema.Literals(["pop", "resolver_ip"]),
+                    Schema.Null,
+                ])),
+                preferEcs: Schema.optional(Schema.Union([
+                    Schema.Literals(["always", "never", "proximity", "geo"]),
+                    Schema.Null,
+                ])),
+            }).pipe(Schema.encodeKeys({ mode: "mode", preferEcs: "prefer_ecs" })),
+            Schema.Null,
+        ])),
+        modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        networks: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+        popPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+        proxied: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        randomSteering: Schema.optional(Schema.Union([
+            Schema.Struct({
+                defaultWeight: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                poolWeights: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                defaultWeight: "default_weight",
+                poolWeights: "pool_weights",
+            })),
+            Schema.Null,
+        ])),
+        regionPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+        rules: Schema.optional(Schema.Union([
+            Schema.Array(Schema.Struct({
+                condition: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                fixedResponse: Schema.optional(Schema.Union([
+                    Schema.Struct({
+                        contentType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        location: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        messageBody: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        statusCode: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                    }).pipe(Schema.encodeKeys({
+                        contentType: "content_type",
+                        location: "location",
+                        messageBody: "message_body",
+                        statusCode: "status_code",
+                    })),
+                    Schema.Null,
+                ])),
+                name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                overrides: Schema.optional(Schema.Union([
+                    Schema.Struct({
+                        adaptiveRouting: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                        countryPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                        defaultPools: Schema.optional(Schema.Union([
+                            Schema.Array(Schema.String),
+                            Schema.Null,
+                        ])),
+                        fallbackPool: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        locationStrategy: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                        popPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                        randomSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                        regionPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                        sessionAffinity: Schema.optional(Schema.Union([
+                            Schema.Literals([
+                                "none",
+                                "cookie",
+                                "ip_cookie",
+                                "header",
+                            ]),
+                            Schema.Null,
+                        ])),
+                        sessionAffinityAttributes: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                        sessionAffinityTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                        steeringPolicy: Schema.optional(Schema.Union([
+                            Schema.Literals([
+                                "",
+                                "off",
+                                "geo",
+                                "random",
+                                "dynamic_latency",
+                                "proximity",
+                                "least_outstanding_requests",
+                                "least_connections",
+                            ]),
+                            Schema.Null,
+                        ])),
+                        ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                    }).pipe(Schema.encodeKeys({
+                        adaptiveRouting: "adaptive_routing",
+                        countryPools: "country_pools",
+                        defaultPools: "default_pools",
+                        fallbackPool: "fallback_pool",
+                        locationStrategy: "location_strategy",
+                        popPools: "pop_pools",
+                        randomSteering: "random_steering",
+                        regionPools: "region_pools",
+                        sessionAffinity: "session_affinity",
+                        sessionAffinityAttributes: "session_affinity_attributes",
+                        sessionAffinityTtl: "session_affinity_ttl",
+                        steeringPolicy: "steering_policy",
+                        ttl: "ttl",
+                    })),
+                    Schema.Null,
+                ])),
+                priority: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                terminates: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                condition: "condition",
+                disabled: "disabled",
+                fixedResponse: "fixed_response",
+                name: "name",
+                overrides: "overrides",
+                priority: "priority",
+                terminates: "terminates",
+            }))),
+            Schema.Null,
+        ])),
+        sessionAffinity: Schema.optional(Schema.Union([
+            Schema.Literals(["none", "cookie", "ip_cookie", "header"]),
+            Schema.Null,
+        ])),
+        sessionAffinityAttributes: Schema.optional(Schema.Union([
+            Schema.Struct({
+                drainDuration: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                headers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                requireAllHeaders: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                samesite: Schema.optional(Schema.Union([
+                    Schema.Literals(["Auto", "Lax", "None", "Strict"]),
+                    Schema.Null,
+                ])),
+                secure: Schema.optional(Schema.Union([
+                    Schema.Literals(["Auto", "Always", "Never"]),
+                    Schema.Null,
+                ])),
+                zeroDowntimeFailover: Schema.optional(Schema.Union([
+                    Schema.Literals(["none", "temporary", "sticky"]),
+                    Schema.Null,
+                ])),
+            }).pipe(Schema.encodeKeys({
+                drainDuration: "drain_duration",
+                headers: "headers",
+                requireAllHeaders: "require_all_headers",
+                samesite: "samesite",
+                secure: "secure",
+                zeroDowntimeFailover: "zero_downtime_failover",
+            })),
+            Schema.Null,
+        ])),
+        sessionAffinityTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        steeringPolicy: Schema.optional(Schema.Union([
+            Schema.Literals([
+                "",
+                "off",
+                "geo",
+                "random",
+                "dynamic_latency",
+                "proximity",
+                "least_outstanding_requests",
+                "least_connections",
+            ]),
+            Schema.Null,
+        ])),
+        ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        zoneName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        adaptiveRouting: "adaptive_routing",
+        countryPools: "country_pools",
+        createdOn: "created_on",
+        defaultPools: "default_pools",
+        description: "description",
+        enabled: "enabled",
+        fallbackPool: "fallback_pool",
+        locationStrategy: "location_strategy",
+        modifiedOn: "modified_on",
+        name: "name",
+        networks: "networks",
+        popPools: "pop_pools",
+        proxied: "proxied",
+        randomSteering: "random_steering",
+        regionPools: "region_pools",
+        rules: "rules",
+        sessionAffinity: "session_affinity",
+        sessionAffinityAttributes: "session_affinity_attributes",
+        sessionAffinityTtl: "session_affinity_ttl",
+        steeringPolicy: "steering_policy",
+        ttl: "ttl",
+        zoneName: "zone_name",
+    }))),
+});
+export const listLoadBalancers = API.makePaginated(() => ({
+    input: ListLoadBalancersRequest,
+    output: ListLoadBalancersResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const CreateLoadBalancerRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    defaultPools: Schema.Array(Schema.String),
+    fallbackPool: Schema.String,
+    name: Schema.String,
+    adaptiveRouting: Schema.optional(Schema.Struct({
+        failoverAcrossPools: Schema.optional(Schema.Boolean),
+    }).pipe(Schema.encodeKeys({ failoverAcrossPools: "failover_across_pools" }))),
+    countryPools: Schema.optional(Schema.Struct({})),
+    description: Schema.optional(Schema.String),
+    locationStrategy: Schema.optional(Schema.Struct({
+        mode: Schema.optional(Schema.Literals(["pop", "resolver_ip"])),
+        preferEcs: Schema.optional(Schema.Literals(["always", "never", "proximity", "geo"])),
+    }).pipe(Schema.encodeKeys({ mode: "mode", preferEcs: "prefer_ecs" }))),
+    networks: Schema.optional(Schema.Array(Schema.String)),
+    popPools: Schema.optional(Schema.Struct({})),
+    proxied: Schema.optional(Schema.Boolean),
+    randomSteering: Schema.optional(Schema.Struct({
+        defaultWeight: Schema.optional(Schema.Number),
+        poolWeights: Schema.optional(Schema.Struct({})),
+    }).pipe(Schema.encodeKeys({
+        defaultWeight: "default_weight",
+        poolWeights: "pool_weights",
+    }))),
+    regionPools: Schema.optional(Schema.Struct({})),
+    rules: Schema.optional(Schema.Array(Schema.Struct({
+        condition: Schema.optional(Schema.String),
+        disabled: Schema.optional(Schema.Boolean),
+        fixedResponse: Schema.optional(Schema.Struct({
+            contentType: Schema.optional(Schema.String),
+            location: Schema.optional(Schema.String),
+            messageBody: Schema.optional(Schema.String),
+            statusCode: Schema.optional(Schema.Number),
+        }).pipe(Schema.encodeKeys({
+            contentType: "content_type",
+            location: "location",
+            messageBody: "message_body",
+            statusCode: "status_code",
+        }))),
+        name: Schema.optional(Schema.String),
+        overrides: Schema.optional(Schema.Struct({
+            adaptiveRouting: Schema.optional(Schema.Unknown),
+            countryPools: Schema.optional(Schema.Struct({})),
+            defaultPools: Schema.optional(Schema.Array(Schema.String)),
+            fallbackPool: Schema.optional(Schema.String),
+            locationStrategy: Schema.optional(Schema.Unknown),
+            popPools: Schema.optional(Schema.Struct({})),
+            randomSteering: Schema.optional(Schema.Unknown),
+            regionPools: Schema.optional(Schema.Struct({})),
+            sessionAffinity: Schema.optional(Schema.Literals(["none", "cookie", "ip_cookie", "header"])),
+            sessionAffinityAttributes: Schema.optional(Schema.Unknown),
+            sessionAffinityTtl: Schema.optional(Schema.Number),
+            steeringPolicy: Schema.optional(Schema.Literals([
+                "",
+                "off",
+                "geo",
+                "random",
+                "dynamic_latency",
+                "proximity",
+                "least_outstanding_requests",
+                "least_connections",
+            ])),
+            ttl: Schema.optional(Schema.Number),
+        }).pipe(Schema.encodeKeys({
+            adaptiveRouting: "adaptive_routing",
+            countryPools: "country_pools",
+            defaultPools: "default_pools",
+            fallbackPool: "fallback_pool",
+            locationStrategy: "location_strategy",
+            popPools: "pop_pools",
+            randomSteering: "random_steering",
+            regionPools: "region_pools",
+            sessionAffinity: "session_affinity",
+            sessionAffinityAttributes: "session_affinity_attributes",
+            sessionAffinityTtl: "session_affinity_ttl",
+            steeringPolicy: "steering_policy",
+            ttl: "ttl",
+        }))),
+        priority: Schema.optional(Schema.Number),
+        terminates: Schema.optional(Schema.Boolean),
+    }).pipe(Schema.encodeKeys({
+        condition: "condition",
+        disabled: "disabled",
+        fixedResponse: "fixed_response",
+        name: "name",
+        overrides: "overrides",
+        priority: "priority",
+        terminates: "terminates",
+    })))),
+    sessionAffinity: Schema.optional(Schema.Literals(["none", "cookie", "ip_cookie", "header"])),
+    sessionAffinityAttributes: Schema.optional(Schema.Struct({
+        drainDuration: Schema.optional(Schema.Number),
+        headers: Schema.optional(Schema.Array(Schema.String)),
+        requireAllHeaders: Schema.optional(Schema.Boolean),
+        samesite: Schema.optional(Schema.Literals(["Auto", "Lax", "None", "Strict"])),
+        secure: Schema.optional(Schema.Literals(["Auto", "Always", "Never"])),
+        zeroDowntimeFailover: Schema.optional(Schema.Literals(["none", "temporary", "sticky"])),
+    }).pipe(Schema.encodeKeys({
+        drainDuration: "drain_duration",
+        headers: "headers",
+        requireAllHeaders: "require_all_headers",
+        samesite: "samesite",
+        secure: "secure",
+        zeroDowntimeFailover: "zero_downtime_failover",
+    }))),
+    sessionAffinityTtl: Schema.optional(Schema.Number),
+    steeringPolicy: Schema.optional(Schema.Literals([
+        "",
+        "off",
+        "geo",
+        "random",
+        "dynamic_latency",
+        "proximity",
+        "least_outstanding_requests",
+        "least_connections",
+    ])),
+    ttl: Schema.optional(Schema.Number),
+}).pipe(Schema.encodeKeys({
+    defaultPools: "default_pools",
+    fallbackPool: "fallback_pool",
+    name: "name",
+    adaptiveRouting: "adaptive_routing",
+    countryPools: "country_pools",
+    description: "description",
+    locationStrategy: "location_strategy",
+    networks: "networks",
+    popPools: "pop_pools",
+    proxied: "proxied",
+    randomSteering: "random_steering",
+    regionPools: "region_pools",
+    rules: "rules",
+    sessionAffinity: "session_affinity",
+    sessionAffinityAttributes: "session_affinity_attributes",
+    sessionAffinityTtl: "session_affinity_ttl",
+    steeringPolicy: "steering_policy",
+    ttl: "ttl",
+}), T.Http({ method: "POST", path: "/zones/{zone_id}/load_balancers" }));
+export const CreateLoadBalancerResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    adaptiveRouting: Schema.optional(Schema.Union([
+        Schema.Struct({
+            failoverAcrossPools: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        }).pipe(Schema.encodeKeys({ failoverAcrossPools: "failover_across_pools" })),
+        Schema.Null,
+    ])),
+    countryPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    defaultPools: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    fallbackPool: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    locationStrategy: Schema.optional(Schema.Union([
+        Schema.Struct({
+            mode: Schema.optional(Schema.Union([
+                Schema.Literals(["pop", "resolver_ip"]),
+                Schema.Null,
+            ])),
+            preferEcs: Schema.optional(Schema.Union([
+                Schema.Literals(["always", "never", "proximity", "geo"]),
+                Schema.Null,
+            ])),
+        }).pipe(Schema.encodeKeys({ mode: "mode", preferEcs: "prefer_ecs" })),
+        Schema.Null,
+    ])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    networks: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    popPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    proxied: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    randomSteering: Schema.optional(Schema.Union([
+        Schema.Struct({
+            defaultWeight: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            poolWeights: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            defaultWeight: "default_weight",
+            poolWeights: "pool_weights",
+        })),
+        Schema.Null,
+    ])),
+    regionPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    rules: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Struct({
+            condition: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            fixedResponse: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    contentType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    location: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    messageBody: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    statusCode: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    contentType: "content_type",
+                    location: "location",
+                    messageBody: "message_body",
+                    statusCode: "status_code",
+                })),
+                Schema.Null,
+            ])),
+            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            overrides: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    adaptiveRouting: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    countryPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                    defaultPools: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                    fallbackPool: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    locationStrategy: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    popPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                    randomSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    regionPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                    sessionAffinity: Schema.optional(Schema.Union([
+                        Schema.Literals([
+                            "none",
+                            "cookie",
+                            "ip_cookie",
+                            "header",
+                        ]),
+                        Schema.Null,
+                    ])),
+                    sessionAffinityAttributes: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    sessionAffinityTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                    steeringPolicy: Schema.optional(Schema.Union([
+                        Schema.Literals([
+                            "",
+                            "off",
+                            "geo",
+                            "random",
+                            "dynamic_latency",
+                            "proximity",
+                            "least_outstanding_requests",
+                            "least_connections",
+                        ]),
+                        Schema.Null,
+                    ])),
+                    ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    adaptiveRouting: "adaptive_routing",
+                    countryPools: "country_pools",
+                    defaultPools: "default_pools",
+                    fallbackPool: "fallback_pool",
+                    locationStrategy: "location_strategy",
+                    popPools: "pop_pools",
+                    randomSteering: "random_steering",
+                    regionPools: "region_pools",
+                    sessionAffinity: "session_affinity",
+                    sessionAffinityAttributes: "session_affinity_attributes",
+                    sessionAffinityTtl: "session_affinity_ttl",
+                    steeringPolicy: "steering_policy",
+                    ttl: "ttl",
+                })),
+                Schema.Null,
+            ])),
+            priority: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            terminates: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            condition: "condition",
+            disabled: "disabled",
+            fixedResponse: "fixed_response",
+            name: "name",
+            overrides: "overrides",
+            priority: "priority",
+            terminates: "terminates",
+        }))),
+        Schema.Null,
+    ])),
+    sessionAffinity: Schema.optional(Schema.Union([
+        Schema.Literals(["none", "cookie", "ip_cookie", "header"]),
+        Schema.Null,
+    ])),
+    sessionAffinityAttributes: Schema.optional(Schema.Union([
+        Schema.Struct({
+            drainDuration: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            headers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+            requireAllHeaders: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            samesite: Schema.optional(Schema.Union([
+                Schema.Literals(["Auto", "Lax", "None", "Strict"]),
+                Schema.Null,
+            ])),
+            secure: Schema.optional(Schema.Union([
+                Schema.Literals(["Auto", "Always", "Never"]),
+                Schema.Null,
+            ])),
+            zeroDowntimeFailover: Schema.optional(Schema.Union([
+                Schema.Literals(["none", "temporary", "sticky"]),
+                Schema.Null,
+            ])),
+        }).pipe(Schema.encodeKeys({
+            drainDuration: "drain_duration",
+            headers: "headers",
+            requireAllHeaders: "require_all_headers",
+            samesite: "samesite",
+            secure: "secure",
+            zeroDowntimeFailover: "zero_downtime_failover",
+        })),
+        Schema.Null,
+    ])),
+    sessionAffinityTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    steeringPolicy: Schema.optional(Schema.Union([
+        Schema.Literals([
+            "",
+            "off",
+            "geo",
+            "random",
+            "dynamic_latency",
+            "proximity",
+            "least_outstanding_requests",
+            "least_connections",
+        ]),
+        Schema.Null,
+    ])),
+    ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    zoneName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    adaptiveRouting: "adaptive_routing",
+    countryPools: "country_pools",
+    createdOn: "created_on",
+    defaultPools: "default_pools",
+    description: "description",
+    enabled: "enabled",
+    fallbackPool: "fallback_pool",
+    locationStrategy: "location_strategy",
+    modifiedOn: "modified_on",
+    name: "name",
+    networks: "networks",
+    popPools: "pop_pools",
+    proxied: "proxied",
+    randomSteering: "random_steering",
+    regionPools: "region_pools",
+    rules: "rules",
+    sessionAffinity: "session_affinity",
+    sessionAffinityAttributes: "session_affinity_attributes",
+    sessionAffinityTtl: "session_affinity_ttl",
+    steeringPolicy: "steering_policy",
+    ttl: "ttl",
+    zoneName: "zone_name",
+}))
+    .pipe(T.ResponsePath("result"));
+export const createLoadBalancer = API.make(() => ({
+    input: CreateLoadBalancerRequest,
+    output: CreateLoadBalancerResponse,
+    errors: [],
+}));
+export const UpdateLoadBalancerRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    loadBalancerId: Schema.String.pipe(T.HttpPath("loadBalancerId")),
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    defaultPools: Schema.Array(Schema.String),
+    fallbackPool: Schema.String,
+    name: Schema.String,
+    adaptiveRouting: Schema.optional(Schema.Struct({
+        failoverAcrossPools: Schema.optional(Schema.Boolean),
+    }).pipe(Schema.encodeKeys({ failoverAcrossPools: "failover_across_pools" }))),
+    countryPools: Schema.optional(Schema.Struct({})),
+    description: Schema.optional(Schema.String),
+    enabled: Schema.optional(Schema.Boolean),
+    locationStrategy: Schema.optional(Schema.Struct({
+        mode: Schema.optional(Schema.Literals(["pop", "resolver_ip"])),
+        preferEcs: Schema.optional(Schema.Literals(["always", "never", "proximity", "geo"])),
+    }).pipe(Schema.encodeKeys({ mode: "mode", preferEcs: "prefer_ecs" }))),
+    networks: Schema.optional(Schema.Array(Schema.String)),
+    popPools: Schema.optional(Schema.Struct({})),
+    proxied: Schema.optional(Schema.Boolean),
+    randomSteering: Schema.optional(Schema.Struct({
+        defaultWeight: Schema.optional(Schema.Number),
+        poolWeights: Schema.optional(Schema.Struct({})),
+    }).pipe(Schema.encodeKeys({
+        defaultWeight: "default_weight",
+        poolWeights: "pool_weights",
+    }))),
+    regionPools: Schema.optional(Schema.Struct({})),
+    rules: Schema.optional(Schema.Array(Schema.Struct({
+        condition: Schema.optional(Schema.String),
+        disabled: Schema.optional(Schema.Boolean),
+        fixedResponse: Schema.optional(Schema.Struct({
+            contentType: Schema.optional(Schema.String),
+            location: Schema.optional(Schema.String),
+            messageBody: Schema.optional(Schema.String),
+            statusCode: Schema.optional(Schema.Number),
+        }).pipe(Schema.encodeKeys({
+            contentType: "content_type",
+            location: "location",
+            messageBody: "message_body",
+            statusCode: "status_code",
+        }))),
+        name: Schema.optional(Schema.String),
+        overrides: Schema.optional(Schema.Struct({
+            adaptiveRouting: Schema.optional(Schema.Unknown),
+            countryPools: Schema.optional(Schema.Struct({})),
+            defaultPools: Schema.optional(Schema.Array(Schema.String)),
+            fallbackPool: Schema.optional(Schema.String),
+            locationStrategy: Schema.optional(Schema.Unknown),
+            popPools: Schema.optional(Schema.Struct({})),
+            randomSteering: Schema.optional(Schema.Unknown),
+            regionPools: Schema.optional(Schema.Struct({})),
+            sessionAffinity: Schema.optional(Schema.Literals(["none", "cookie", "ip_cookie", "header"])),
+            sessionAffinityAttributes: Schema.optional(Schema.Unknown),
+            sessionAffinityTtl: Schema.optional(Schema.Number),
+            steeringPolicy: Schema.optional(Schema.Literals([
+                "",
+                "off",
+                "geo",
+                "random",
+                "dynamic_latency",
+                "proximity",
+                "least_outstanding_requests",
+                "least_connections",
+            ])),
+            ttl: Schema.optional(Schema.Number),
+        }).pipe(Schema.encodeKeys({
+            adaptiveRouting: "adaptive_routing",
+            countryPools: "country_pools",
+            defaultPools: "default_pools",
+            fallbackPool: "fallback_pool",
+            locationStrategy: "location_strategy",
+            popPools: "pop_pools",
+            randomSteering: "random_steering",
+            regionPools: "region_pools",
+            sessionAffinity: "session_affinity",
+            sessionAffinityAttributes: "session_affinity_attributes",
+            sessionAffinityTtl: "session_affinity_ttl",
+            steeringPolicy: "steering_policy",
+            ttl: "ttl",
+        }))),
+        priority: Schema.optional(Schema.Number),
+        terminates: Schema.optional(Schema.Boolean),
+    }).pipe(Schema.encodeKeys({
+        condition: "condition",
+        disabled: "disabled",
+        fixedResponse: "fixed_response",
+        name: "name",
+        overrides: "overrides",
+        priority: "priority",
+        terminates: "terminates",
+    })))),
+    sessionAffinity: Schema.optional(Schema.Literals(["none", "cookie", "ip_cookie", "header"])),
+    sessionAffinityAttributes: Schema.optional(Schema.Struct({
+        drainDuration: Schema.optional(Schema.Number),
+        headers: Schema.optional(Schema.Array(Schema.String)),
+        requireAllHeaders: Schema.optional(Schema.Boolean),
+        samesite: Schema.optional(Schema.Literals(["Auto", "Lax", "None", "Strict"])),
+        secure: Schema.optional(Schema.Literals(["Auto", "Always", "Never"])),
+        zeroDowntimeFailover: Schema.optional(Schema.Literals(["none", "temporary", "sticky"])),
+    }).pipe(Schema.encodeKeys({
+        drainDuration: "drain_duration",
+        headers: "headers",
+        requireAllHeaders: "require_all_headers",
+        samesite: "samesite",
+        secure: "secure",
+        zeroDowntimeFailover: "zero_downtime_failover",
+    }))),
+    sessionAffinityTtl: Schema.optional(Schema.Number),
+    steeringPolicy: Schema.optional(Schema.Literals([
+        "",
+        "off",
+        "geo",
+        "random",
+        "dynamic_latency",
+        "proximity",
+        "least_outstanding_requests",
+        "least_connections",
+    ])),
+    ttl: Schema.optional(Schema.Number),
+}).pipe(Schema.encodeKeys({
+    defaultPools: "default_pools",
+    fallbackPool: "fallback_pool",
+    name: "name",
+    adaptiveRouting: "adaptive_routing",
+    countryPools: "country_pools",
+    description: "description",
+    enabled: "enabled",
+    locationStrategy: "location_strategy",
+    networks: "networks",
+    popPools: "pop_pools",
+    proxied: "proxied",
+    randomSteering: "random_steering",
+    regionPools: "region_pools",
+    rules: "rules",
+    sessionAffinity: "session_affinity",
+    sessionAffinityAttributes: "session_affinity_attributes",
+    sessionAffinityTtl: "session_affinity_ttl",
+    steeringPolicy: "steering_policy",
+    ttl: "ttl",
+}), T.Http({
+    method: "PUT",
+    path: "/zones/{zone_id}/load_balancers/{loadBalancerId}",
+}));
+export const UpdateLoadBalancerResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    adaptiveRouting: Schema.optional(Schema.Union([
+        Schema.Struct({
+            failoverAcrossPools: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        }).pipe(Schema.encodeKeys({ failoverAcrossPools: "failover_across_pools" })),
+        Schema.Null,
+    ])),
+    countryPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    defaultPools: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    fallbackPool: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    locationStrategy: Schema.optional(Schema.Union([
+        Schema.Struct({
+            mode: Schema.optional(Schema.Union([
+                Schema.Literals(["pop", "resolver_ip"]),
+                Schema.Null,
+            ])),
+            preferEcs: Schema.optional(Schema.Union([
+                Schema.Literals(["always", "never", "proximity", "geo"]),
+                Schema.Null,
+            ])),
+        }).pipe(Schema.encodeKeys({ mode: "mode", preferEcs: "prefer_ecs" })),
+        Schema.Null,
+    ])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    networks: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    popPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    proxied: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    randomSteering: Schema.optional(Schema.Union([
+        Schema.Struct({
+            defaultWeight: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            poolWeights: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            defaultWeight: "default_weight",
+            poolWeights: "pool_weights",
+        })),
+        Schema.Null,
+    ])),
+    regionPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    rules: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Struct({
+            condition: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            fixedResponse: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    contentType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    location: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    messageBody: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    statusCode: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    contentType: "content_type",
+                    location: "location",
+                    messageBody: "message_body",
+                    statusCode: "status_code",
+                })),
+                Schema.Null,
+            ])),
+            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            overrides: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    adaptiveRouting: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    countryPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                    defaultPools: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                    fallbackPool: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    locationStrategy: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    popPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                    randomSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    regionPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                    sessionAffinity: Schema.optional(Schema.Union([
+                        Schema.Literals([
+                            "none",
+                            "cookie",
+                            "ip_cookie",
+                            "header",
+                        ]),
+                        Schema.Null,
+                    ])),
+                    sessionAffinityAttributes: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    sessionAffinityTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                    steeringPolicy: Schema.optional(Schema.Union([
+                        Schema.Literals([
+                            "",
+                            "off",
+                            "geo",
+                            "random",
+                            "dynamic_latency",
+                            "proximity",
+                            "least_outstanding_requests",
+                            "least_connections",
+                        ]),
+                        Schema.Null,
+                    ])),
+                    ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    adaptiveRouting: "adaptive_routing",
+                    countryPools: "country_pools",
+                    defaultPools: "default_pools",
+                    fallbackPool: "fallback_pool",
+                    locationStrategy: "location_strategy",
+                    popPools: "pop_pools",
+                    randomSteering: "random_steering",
+                    regionPools: "region_pools",
+                    sessionAffinity: "session_affinity",
+                    sessionAffinityAttributes: "session_affinity_attributes",
+                    sessionAffinityTtl: "session_affinity_ttl",
+                    steeringPolicy: "steering_policy",
+                    ttl: "ttl",
+                })),
+                Schema.Null,
+            ])),
+            priority: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            terminates: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            condition: "condition",
+            disabled: "disabled",
+            fixedResponse: "fixed_response",
+            name: "name",
+            overrides: "overrides",
+            priority: "priority",
+            terminates: "terminates",
+        }))),
+        Schema.Null,
+    ])),
+    sessionAffinity: Schema.optional(Schema.Union([
+        Schema.Literals(["none", "cookie", "ip_cookie", "header"]),
+        Schema.Null,
+    ])),
+    sessionAffinityAttributes: Schema.optional(Schema.Union([
+        Schema.Struct({
+            drainDuration: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            headers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+            requireAllHeaders: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            samesite: Schema.optional(Schema.Union([
+                Schema.Literals(["Auto", "Lax", "None", "Strict"]),
+                Schema.Null,
+            ])),
+            secure: Schema.optional(Schema.Union([
+                Schema.Literals(["Auto", "Always", "Never"]),
+                Schema.Null,
+            ])),
+            zeroDowntimeFailover: Schema.optional(Schema.Union([
+                Schema.Literals(["none", "temporary", "sticky"]),
+                Schema.Null,
+            ])),
+        }).pipe(Schema.encodeKeys({
+            drainDuration: "drain_duration",
+            headers: "headers",
+            requireAllHeaders: "require_all_headers",
+            samesite: "samesite",
+            secure: "secure",
+            zeroDowntimeFailover: "zero_downtime_failover",
+        })),
+        Schema.Null,
+    ])),
+    sessionAffinityTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    steeringPolicy: Schema.optional(Schema.Union([
+        Schema.Literals([
+            "",
+            "off",
+            "geo",
+            "random",
+            "dynamic_latency",
+            "proximity",
+            "least_outstanding_requests",
+            "least_connections",
+        ]),
+        Schema.Null,
+    ])),
+    ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    zoneName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    adaptiveRouting: "adaptive_routing",
+    countryPools: "country_pools",
+    createdOn: "created_on",
+    defaultPools: "default_pools",
+    description: "description",
+    enabled: "enabled",
+    fallbackPool: "fallback_pool",
+    locationStrategy: "location_strategy",
+    modifiedOn: "modified_on",
+    name: "name",
+    networks: "networks",
+    popPools: "pop_pools",
+    proxied: "proxied",
+    randomSteering: "random_steering",
+    regionPools: "region_pools",
+    rules: "rules",
+    sessionAffinity: "session_affinity",
+    sessionAffinityAttributes: "session_affinity_attributes",
+    sessionAffinityTtl: "session_affinity_ttl",
+    steeringPolicy: "steering_policy",
+    ttl: "ttl",
+    zoneName: "zone_name",
+}))
+    .pipe(T.ResponsePath("result"));
+export const updateLoadBalancer = API.make(() => ({
+    input: UpdateLoadBalancerRequest,
+    output: UpdateLoadBalancerResponse,
+    errors: [],
+}));
+export const PatchLoadBalancerRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    loadBalancerId: Schema.String.pipe(T.HttpPath("loadBalancerId")),
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    adaptiveRouting: Schema.optional(Schema.Struct({
+        failoverAcrossPools: Schema.optional(Schema.Boolean),
+    }).pipe(Schema.encodeKeys({ failoverAcrossPools: "failover_across_pools" }))),
+    countryPools: Schema.optional(Schema.Struct({})),
+    defaultPools: Schema.optional(Schema.Array(Schema.String)),
+    description: Schema.optional(Schema.String),
+    enabled: Schema.optional(Schema.Boolean),
+    fallbackPool: Schema.optional(Schema.String),
+    locationStrategy: Schema.optional(Schema.Struct({
+        mode: Schema.optional(Schema.Literals(["pop", "resolver_ip"])),
+        preferEcs: Schema.optional(Schema.Literals(["always", "never", "proximity", "geo"])),
+    }).pipe(Schema.encodeKeys({ mode: "mode", preferEcs: "prefer_ecs" }))),
+    name: Schema.optional(Schema.String),
+    popPools: Schema.optional(Schema.Struct({})),
+    proxied: Schema.optional(Schema.Boolean),
+    randomSteering: Schema.optional(Schema.Struct({
+        defaultWeight: Schema.optional(Schema.Number),
+        poolWeights: Schema.optional(Schema.Struct({})),
+    }).pipe(Schema.encodeKeys({
+        defaultWeight: "default_weight",
+        poolWeights: "pool_weights",
+    }))),
+    regionPools: Schema.optional(Schema.Struct({})),
+    rules: Schema.optional(Schema.Array(Schema.Struct({
+        condition: Schema.optional(Schema.String),
+        disabled: Schema.optional(Schema.Boolean),
+        fixedResponse: Schema.optional(Schema.Struct({
+            contentType: Schema.optional(Schema.String),
+            location: Schema.optional(Schema.String),
+            messageBody: Schema.optional(Schema.String),
+            statusCode: Schema.optional(Schema.Number),
+        }).pipe(Schema.encodeKeys({
+            contentType: "content_type",
+            location: "location",
+            messageBody: "message_body",
+            statusCode: "status_code",
+        }))),
+        name: Schema.optional(Schema.String),
+        overrides: Schema.optional(Schema.Struct({
+            adaptiveRouting: Schema.optional(Schema.Unknown),
+            countryPools: Schema.optional(Schema.Struct({})),
+            defaultPools: Schema.optional(Schema.Array(Schema.String)),
+            fallbackPool: Schema.optional(Schema.String),
+            locationStrategy: Schema.optional(Schema.Unknown),
+            popPools: Schema.optional(Schema.Struct({})),
+            randomSteering: Schema.optional(Schema.Unknown),
+            regionPools: Schema.optional(Schema.Struct({})),
+            sessionAffinity: Schema.optional(Schema.Literals(["none", "cookie", "ip_cookie", "header"])),
+            sessionAffinityAttributes: Schema.optional(Schema.Unknown),
+            sessionAffinityTtl: Schema.optional(Schema.Number),
+            steeringPolicy: Schema.optional(Schema.Literals([
+                "",
+                "off",
+                "geo",
+                "random",
+                "dynamic_latency",
+                "proximity",
+                "least_outstanding_requests",
+                "least_connections",
+            ])),
+            ttl: Schema.optional(Schema.Number),
+        }).pipe(Schema.encodeKeys({
+            adaptiveRouting: "adaptive_routing",
+            countryPools: "country_pools",
+            defaultPools: "default_pools",
+            fallbackPool: "fallback_pool",
+            locationStrategy: "location_strategy",
+            popPools: "pop_pools",
+            randomSteering: "random_steering",
+            regionPools: "region_pools",
+            sessionAffinity: "session_affinity",
+            sessionAffinityAttributes: "session_affinity_attributes",
+            sessionAffinityTtl: "session_affinity_ttl",
+            steeringPolicy: "steering_policy",
+            ttl: "ttl",
+        }))),
+        priority: Schema.optional(Schema.Number),
+        terminates: Schema.optional(Schema.Boolean),
+    }).pipe(Schema.encodeKeys({
+        condition: "condition",
+        disabled: "disabled",
+        fixedResponse: "fixed_response",
+        name: "name",
+        overrides: "overrides",
+        priority: "priority",
+        terminates: "terminates",
+    })))),
+    sessionAffinity: Schema.optional(Schema.Literals(["none", "cookie", "ip_cookie", "header"])),
+    sessionAffinityAttributes: Schema.optional(Schema.Struct({
+        drainDuration: Schema.optional(Schema.Number),
+        headers: Schema.optional(Schema.Array(Schema.String)),
+        requireAllHeaders: Schema.optional(Schema.Boolean),
+        samesite: Schema.optional(Schema.Literals(["Auto", "Lax", "None", "Strict"])),
+        secure: Schema.optional(Schema.Literals(["Auto", "Always", "Never"])),
+        zeroDowntimeFailover: Schema.optional(Schema.Literals(["none", "temporary", "sticky"])),
+    }).pipe(Schema.encodeKeys({
+        drainDuration: "drain_duration",
+        headers: "headers",
+        requireAllHeaders: "require_all_headers",
+        samesite: "samesite",
+        secure: "secure",
+        zeroDowntimeFailover: "zero_downtime_failover",
+    }))),
+    sessionAffinityTtl: Schema.optional(Schema.Number),
+    steeringPolicy: Schema.optional(Schema.Literals([
+        "",
+        "off",
+        "geo",
+        "random",
+        "dynamic_latency",
+        "proximity",
+        "least_outstanding_requests",
+        "least_connections",
+    ])),
+    ttl: Schema.optional(Schema.Number),
+}).pipe(Schema.encodeKeys({
+    adaptiveRouting: "adaptive_routing",
+    countryPools: "country_pools",
+    defaultPools: "default_pools",
+    description: "description",
+    enabled: "enabled",
+    fallbackPool: "fallback_pool",
+    locationStrategy: "location_strategy",
+    name: "name",
+    popPools: "pop_pools",
+    proxied: "proxied",
+    randomSteering: "random_steering",
+    regionPools: "region_pools",
+    rules: "rules",
+    sessionAffinity: "session_affinity",
+    sessionAffinityAttributes: "session_affinity_attributes",
+    sessionAffinityTtl: "session_affinity_ttl",
+    steeringPolicy: "steering_policy",
+    ttl: "ttl",
+}), T.Http({
+    method: "PATCH",
+    path: "/zones/{zone_id}/load_balancers/{loadBalancerId}",
+}));
+export const PatchLoadBalancerResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    adaptiveRouting: Schema.optional(Schema.Union([
+        Schema.Struct({
+            failoverAcrossPools: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        }).pipe(Schema.encodeKeys({ failoverAcrossPools: "failover_across_pools" })),
+        Schema.Null,
+    ])),
+    countryPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    defaultPools: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    fallbackPool: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    locationStrategy: Schema.optional(Schema.Union([
+        Schema.Struct({
+            mode: Schema.optional(Schema.Union([
+                Schema.Literals(["pop", "resolver_ip"]),
+                Schema.Null,
+            ])),
+            preferEcs: Schema.optional(Schema.Union([
+                Schema.Literals(["always", "never", "proximity", "geo"]),
+                Schema.Null,
+            ])),
+        }).pipe(Schema.encodeKeys({ mode: "mode", preferEcs: "prefer_ecs" })),
+        Schema.Null,
+    ])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    networks: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    popPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    proxied: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    randomSteering: Schema.optional(Schema.Union([
+        Schema.Struct({
+            defaultWeight: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            poolWeights: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            defaultWeight: "default_weight",
+            poolWeights: "pool_weights",
+        })),
+        Schema.Null,
+    ])),
+    regionPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    rules: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Struct({
+            condition: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            fixedResponse: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    contentType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    location: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    messageBody: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    statusCode: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    contentType: "content_type",
+                    location: "location",
+                    messageBody: "message_body",
+                    statusCode: "status_code",
+                })),
+                Schema.Null,
+            ])),
+            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            overrides: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    adaptiveRouting: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    countryPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                    defaultPools: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                    fallbackPool: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    locationStrategy: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    popPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                    randomSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    regionPools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+                    sessionAffinity: Schema.optional(Schema.Union([
+                        Schema.Literals([
+                            "none",
+                            "cookie",
+                            "ip_cookie",
+                            "header",
+                        ]),
+                        Schema.Null,
+                    ])),
+                    sessionAffinityAttributes: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+                    sessionAffinityTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                    steeringPolicy: Schema.optional(Schema.Union([
+                        Schema.Literals([
+                            "",
+                            "off",
+                            "geo",
+                            "random",
+                            "dynamic_latency",
+                            "proximity",
+                            "least_outstanding_requests",
+                            "least_connections",
+                        ]),
+                        Schema.Null,
+                    ])),
+                    ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    adaptiveRouting: "adaptive_routing",
+                    countryPools: "country_pools",
+                    defaultPools: "default_pools",
+                    fallbackPool: "fallback_pool",
+                    locationStrategy: "location_strategy",
+                    popPools: "pop_pools",
+                    randomSteering: "random_steering",
+                    regionPools: "region_pools",
+                    sessionAffinity: "session_affinity",
+                    sessionAffinityAttributes: "session_affinity_attributes",
+                    sessionAffinityTtl: "session_affinity_ttl",
+                    steeringPolicy: "steering_policy",
+                    ttl: "ttl",
+                })),
+                Schema.Null,
+            ])),
+            priority: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            terminates: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            condition: "condition",
+            disabled: "disabled",
+            fixedResponse: "fixed_response",
+            name: "name",
+            overrides: "overrides",
+            priority: "priority",
+            terminates: "terminates",
+        }))),
+        Schema.Null,
+    ])),
+    sessionAffinity: Schema.optional(Schema.Union([
+        Schema.Literals(["none", "cookie", "ip_cookie", "header"]),
+        Schema.Null,
+    ])),
+    sessionAffinityAttributes: Schema.optional(Schema.Union([
+        Schema.Struct({
+            drainDuration: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            headers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+            requireAllHeaders: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            samesite: Schema.optional(Schema.Union([
+                Schema.Literals(["Auto", "Lax", "None", "Strict"]),
+                Schema.Null,
+            ])),
+            secure: Schema.optional(Schema.Union([
+                Schema.Literals(["Auto", "Always", "Never"]),
+                Schema.Null,
+            ])),
+            zeroDowntimeFailover: Schema.optional(Schema.Union([
+                Schema.Literals(["none", "temporary", "sticky"]),
+                Schema.Null,
+            ])),
+        }).pipe(Schema.encodeKeys({
+            drainDuration: "drain_duration",
+            headers: "headers",
+            requireAllHeaders: "require_all_headers",
+            samesite: "samesite",
+            secure: "secure",
+            zeroDowntimeFailover: "zero_downtime_failover",
+        })),
+        Schema.Null,
+    ])),
+    sessionAffinityTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    steeringPolicy: Schema.optional(Schema.Union([
+        Schema.Literals([
+            "",
+            "off",
+            "geo",
+            "random",
+            "dynamic_latency",
+            "proximity",
+            "least_outstanding_requests",
+            "least_connections",
+        ]),
+        Schema.Null,
+    ])),
+    ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    zoneName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    adaptiveRouting: "adaptive_routing",
+    countryPools: "country_pools",
+    createdOn: "created_on",
+    defaultPools: "default_pools",
+    description: "description",
+    enabled: "enabled",
+    fallbackPool: "fallback_pool",
+    locationStrategy: "location_strategy",
+    modifiedOn: "modified_on",
+    name: "name",
+    networks: "networks",
+    popPools: "pop_pools",
+    proxied: "proxied",
+    randomSteering: "random_steering",
+    regionPools: "region_pools",
+    rules: "rules",
+    sessionAffinity: "session_affinity",
+    sessionAffinityAttributes: "session_affinity_attributes",
+    sessionAffinityTtl: "session_affinity_ttl",
+    steeringPolicy: "steering_policy",
+    ttl: "ttl",
+    zoneName: "zone_name",
+}))
+    .pipe(T.ResponsePath("result"));
+export const patchLoadBalancer = API.make(() => ({
+    input: PatchLoadBalancerRequest,
+    output: PatchLoadBalancerResponse,
+    errors: [],
+}));
+export const DeleteLoadBalancerRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    loadBalancerId: Schema.String.pipe(T.HttpPath("loadBalancerId")),
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/zones/{zone_id}/load_balancers/{loadBalancerId}",
+}));
+export const DeleteLoadBalancerResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}).pipe(T.ResponsePath("result"));
+export const deleteLoadBalancer = API.make(() => ({
+    input: DeleteLoadBalancerRequest,
+    output: DeleteLoadBalancerResponse,
+    errors: [],
+}));
+export const GetMonitorRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    monitorId: Schema.String.pipe(T.HttpPath("monitorId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/load_balancers/monitors/{monitorId}",
+}));
+export const GetMonitorResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    allowInsecure: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    consecutiveDown: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    consecutiveUp: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    expectedBody: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    expectedCodes: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    followRedirects: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    header: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    interval: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    method: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    probeZone: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    retries: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    type: Schema.optional(Schema.Union([
+        Schema.Literals([
+            "http",
+            "https",
+            "tcp",
+            "udp_icmp",
+            "icmp_ping",
+            "smtp",
+        ]),
+        Schema.Null,
+    ])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    allowInsecure: "allow_insecure",
+    consecutiveDown: "consecutive_down",
+    consecutiveUp: "consecutive_up",
+    createdOn: "created_on",
+    description: "description",
+    expectedBody: "expected_body",
+    expectedCodes: "expected_codes",
+    followRedirects: "follow_redirects",
+    header: "header",
+    interval: "interval",
+    method: "method",
+    modifiedOn: "modified_on",
+    path: "path",
+    port: "port",
+    probeZone: "probe_zone",
+    retries: "retries",
+    timeout: "timeout",
+    type: "type",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getMonitor = API.make(() => ({
+    input: GetMonitorRequest,
+    output: GetMonitorResponse,
+    errors: [],
+}));
+export const ListMonitorsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/load_balancers/monitors",
+}));
+export const ListMonitorsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        allowInsecure: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        consecutiveDown: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        consecutiveUp: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        expectedBody: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        expectedCodes: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        followRedirects: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        header: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+        interval: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        method: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        probeZone: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        retries: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        type: Schema.optional(Schema.Union([
+            Schema.Literals([
+                "http",
+                "https",
+                "tcp",
+                "udp_icmp",
+                "icmp_ping",
+                "smtp",
+            ]),
+            Schema.Null,
+        ])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        allowInsecure: "allow_insecure",
+        consecutiveDown: "consecutive_down",
+        consecutiveUp: "consecutive_up",
+        createdOn: "created_on",
+        description: "description",
+        expectedBody: "expected_body",
+        expectedCodes: "expected_codes",
+        followRedirects: "follow_redirects",
+        header: "header",
+        interval: "interval",
+        method: "method",
+        modifiedOn: "modified_on",
+        path: "path",
+        port: "port",
+        probeZone: "probe_zone",
+        retries: "retries",
+        timeout: "timeout",
+        type: "type",
+    }))),
+});
+export const listMonitors = API.makePaginated(() => ({
+    input: ListMonitorsRequest,
+    output: ListMonitorsResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const CreateMonitorRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    allowInsecure: Schema.optional(Schema.Boolean),
+    consecutiveDown: Schema.optional(Schema.Number),
+    consecutiveUp: Schema.optional(Schema.Number),
+    description: Schema.optional(Schema.String),
+    expectedBody: Schema.optional(Schema.String),
+    expectedCodes: Schema.optional(Schema.String),
+    followRedirects: Schema.optional(Schema.Boolean),
+    header: Schema.optional(Schema.Struct({})),
+    interval: Schema.optional(Schema.Number),
+    method: Schema.optional(Schema.String),
+    path: Schema.optional(Schema.String),
+    port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    probeZone: Schema.optional(Schema.String),
+    retries: Schema.optional(Schema.Number),
+    timeout: Schema.optional(Schema.Number),
+    type: Schema.optional(Schema.Literals(["http", "https", "tcp", "udp_icmp", "icmp_ping", "smtp"])),
+}).pipe(Schema.encodeKeys({
+    allowInsecure: "allow_insecure",
+    consecutiveDown: "consecutive_down",
+    consecutiveUp: "consecutive_up",
+    description: "description",
+    expectedBody: "expected_body",
+    expectedCodes: "expected_codes",
+    followRedirects: "follow_redirects",
+    header: "header",
+    interval: "interval",
+    method: "method",
+    path: "path",
+    port: "port",
+    probeZone: "probe_zone",
+    retries: "retries",
+    timeout: "timeout",
+    type: "type",
+}), T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/load_balancers/monitors",
+}));
+export const CreateMonitorResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    allowInsecure: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    consecutiveDown: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    consecutiveUp: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    expectedBody: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    expectedCodes: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    followRedirects: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    header: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    interval: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    method: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    probeZone: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    retries: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    type: Schema.optional(Schema.Union([
+        Schema.Literals([
+            "http",
+            "https",
+            "tcp",
+            "udp_icmp",
+            "icmp_ping",
+            "smtp",
+        ]),
+        Schema.Null,
+    ])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    allowInsecure: "allow_insecure",
+    consecutiveDown: "consecutive_down",
+    consecutiveUp: "consecutive_up",
+    createdOn: "created_on",
+    description: "description",
+    expectedBody: "expected_body",
+    expectedCodes: "expected_codes",
+    followRedirects: "follow_redirects",
+    header: "header",
+    interval: "interval",
+    method: "method",
+    modifiedOn: "modified_on",
+    path: "path",
+    port: "port",
+    probeZone: "probe_zone",
+    retries: "retries",
+    timeout: "timeout",
+    type: "type",
+}))
+    .pipe(T.ResponsePath("result"));
+export const createMonitor = API.make(() => ({
+    input: CreateMonitorRequest,
+    output: CreateMonitorResponse,
+    errors: [],
+}));
+export const UpdateMonitorRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    monitorId: Schema.String.pipe(T.HttpPath("monitorId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    allowInsecure: Schema.optional(Schema.Boolean),
+    consecutiveDown: Schema.optional(Schema.Number),
+    consecutiveUp: Schema.optional(Schema.Number),
+    description: Schema.optional(Schema.String),
+    expectedBody: Schema.optional(Schema.String),
+    expectedCodes: Schema.optional(Schema.String),
+    followRedirects: Schema.optional(Schema.Boolean),
+    header: Schema.optional(Schema.Struct({})),
+    interval: Schema.optional(Schema.Number),
+    method: Schema.optional(Schema.String),
+    path: Schema.optional(Schema.String),
+    port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    probeZone: Schema.optional(Schema.String),
+    retries: Schema.optional(Schema.Number),
+    timeout: Schema.optional(Schema.Number),
+    type: Schema.optional(Schema.Literals(["http", "https", "tcp", "udp_icmp", "icmp_ping", "smtp"])),
+}).pipe(Schema.encodeKeys({
+    allowInsecure: "allow_insecure",
+    consecutiveDown: "consecutive_down",
+    consecutiveUp: "consecutive_up",
+    description: "description",
+    expectedBody: "expected_body",
+    expectedCodes: "expected_codes",
+    followRedirects: "follow_redirects",
+    header: "header",
+    interval: "interval",
+    method: "method",
+    path: "path",
+    port: "port",
+    probeZone: "probe_zone",
+    retries: "retries",
+    timeout: "timeout",
+    type: "type",
+}), T.Http({
+    method: "PUT",
+    path: "/accounts/{account_id}/load_balancers/monitors/{monitorId}",
+}));
+export const UpdateMonitorResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    allowInsecure: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    consecutiveDown: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    consecutiveUp: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    expectedBody: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    expectedCodes: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    followRedirects: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    header: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    interval: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    method: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    probeZone: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    retries: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    type: Schema.optional(Schema.Union([
+        Schema.Literals([
+            "http",
+            "https",
+            "tcp",
+            "udp_icmp",
+            "icmp_ping",
+            "smtp",
+        ]),
+        Schema.Null,
+    ])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    allowInsecure: "allow_insecure",
+    consecutiveDown: "consecutive_down",
+    consecutiveUp: "consecutive_up",
+    createdOn: "created_on",
+    description: "description",
+    expectedBody: "expected_body",
+    expectedCodes: "expected_codes",
+    followRedirects: "follow_redirects",
+    header: "header",
+    interval: "interval",
+    method: "method",
+    modifiedOn: "modified_on",
+    path: "path",
+    port: "port",
+    probeZone: "probe_zone",
+    retries: "retries",
+    timeout: "timeout",
+    type: "type",
+}))
+    .pipe(T.ResponsePath("result"));
+export const updateMonitor = API.make(() => ({
+    input: UpdateMonitorRequest,
+    output: UpdateMonitorResponse,
+    errors: [],
+}));
+export const PatchMonitorRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    monitorId: Schema.String.pipe(T.HttpPath("monitorId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    allowInsecure: Schema.optional(Schema.Boolean),
+    consecutiveDown: Schema.optional(Schema.Number),
+    consecutiveUp: Schema.optional(Schema.Number),
+    description: Schema.optional(Schema.String),
+    expectedBody: Schema.optional(Schema.String),
+    expectedCodes: Schema.optional(Schema.String),
+    followRedirects: Schema.optional(Schema.Boolean),
+    header: Schema.optional(Schema.Struct({})),
+    interval: Schema.optional(Schema.Number),
+    method: Schema.optional(Schema.String),
+    path: Schema.optional(Schema.String),
+    port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    probeZone: Schema.optional(Schema.String),
+    retries: Schema.optional(Schema.Number),
+    timeout: Schema.optional(Schema.Number),
+    type: Schema.optional(Schema.Literals(["http", "https", "tcp", "udp_icmp", "icmp_ping", "smtp"])),
+}).pipe(Schema.encodeKeys({
+    allowInsecure: "allow_insecure",
+    consecutiveDown: "consecutive_down",
+    consecutiveUp: "consecutive_up",
+    description: "description",
+    expectedBody: "expected_body",
+    expectedCodes: "expected_codes",
+    followRedirects: "follow_redirects",
+    header: "header",
+    interval: "interval",
+    method: "method",
+    path: "path",
+    port: "port",
+    probeZone: "probe_zone",
+    retries: "retries",
+    timeout: "timeout",
+    type: "type",
+}), T.Http({
+    method: "PATCH",
+    path: "/accounts/{account_id}/load_balancers/monitors/{monitorId}",
+}));
+export const PatchMonitorResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    allowInsecure: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    consecutiveDown: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    consecutiveUp: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    expectedBody: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    expectedCodes: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    followRedirects: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    header: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    interval: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    method: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    probeZone: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    retries: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    type: Schema.optional(Schema.Union([
+        Schema.Literals([
+            "http",
+            "https",
+            "tcp",
+            "udp_icmp",
+            "icmp_ping",
+            "smtp",
+        ]),
+        Schema.Null,
+    ])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    allowInsecure: "allow_insecure",
+    consecutiveDown: "consecutive_down",
+    consecutiveUp: "consecutive_up",
+    createdOn: "created_on",
+    description: "description",
+    expectedBody: "expected_body",
+    expectedCodes: "expected_codes",
+    followRedirects: "follow_redirects",
+    header: "header",
+    interval: "interval",
+    method: "method",
+    modifiedOn: "modified_on",
+    path: "path",
+    port: "port",
+    probeZone: "probe_zone",
+    retries: "retries",
+    timeout: "timeout",
+    type: "type",
+}))
+    .pipe(T.ResponsePath("result"));
+export const patchMonitor = API.make(() => ({
+    input: PatchMonitorRequest,
+    output: PatchMonitorResponse,
+    errors: [],
+}));
+export const DeleteMonitorRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    monitorId: Schema.String.pipe(T.HttpPath("monitorId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/load_balancers/monitors/{monitorId}",
+}));
+export const DeleteMonitorResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}).pipe(T.ResponsePath("result"));
+export const deleteMonitor = API.make(() => ({
+    input: DeleteMonitorRequest,
+    output: DeleteMonitorResponse,
+    errors: [],
+}));
+export const GetMonitorGroupRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    monitorGroupId: Schema.String.pipe(T.HttpPath("monitorGroupId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/load_balancers/monitor_groups/{monitorGroupId}",
+}));
+export const GetMonitorGroupResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    description: Schema.String,
+    members: Schema.Array(Schema.Struct({
+        enabled: Schema.Boolean,
+        monitorId: Schema.String,
+        monitoringOnly: Schema.Boolean,
+        mustBeHealthy: Schema.Boolean,
+        createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        enabled: "enabled",
+        monitorId: "monitor_id",
+        monitoringOnly: "monitoring_only",
+        mustBeHealthy: "must_be_healthy",
+        createdAt: "created_at",
+        updatedAt: "updated_at",
+    }))),
+    createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    description: "description",
+    members: "members",
+    createdAt: "created_at",
+    updatedAt: "updated_at",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getMonitorGroup = API.make(() => ({
+    input: GetMonitorGroupRequest,
+    output: GetMonitorGroupResponse,
+    errors: [],
+}));
+export const ListMonitorGroupsRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/load_balancers/monitor_groups",
+}));
+export const ListMonitorGroupsResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        description: Schema.String,
+        members: Schema.Array(Schema.Struct({
+            enabled: Schema.Boolean,
+            monitorId: Schema.String,
+            monitoringOnly: Schema.Boolean,
+            mustBeHealthy: Schema.Boolean,
+            createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            enabled: "enabled",
+            monitorId: "monitor_id",
+            monitoringOnly: "monitoring_only",
+            mustBeHealthy: "must_be_healthy",
+            createdAt: "created_at",
+            updatedAt: "updated_at",
+        }))),
+        createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        description: "description",
+        members: "members",
+        createdAt: "created_at",
+        updatedAt: "updated_at",
+    }))),
+});
+export const listMonitorGroups = API.makePaginated(() => ({
+    input: ListMonitorGroupsRequest,
+    output: ListMonitorGroupsResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const CreateMonitorGroupRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    id: Schema.String,
+    description: Schema.String,
+    members: Schema.Array(Schema.Struct({
+        enabled: Schema.Boolean,
+        monitorId: Schema.String,
+        monitoringOnly: Schema.Boolean,
+        mustBeHealthy: Schema.Boolean,
+    }).pipe(Schema.encodeKeys({
+        enabled: "enabled",
+        monitorId: "monitor_id",
+        monitoringOnly: "monitoring_only",
+        mustBeHealthy: "must_be_healthy",
+    }))),
+}).pipe(T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/load_balancers/monitor_groups",
+}));
+export const CreateMonitorGroupResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    description: Schema.String,
+    members: Schema.Array(Schema.Struct({
+        enabled: Schema.Boolean,
+        monitorId: Schema.String,
+        monitoringOnly: Schema.Boolean,
+        mustBeHealthy: Schema.Boolean,
+        createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        enabled: "enabled",
+        monitorId: "monitor_id",
+        monitoringOnly: "monitoring_only",
+        mustBeHealthy: "must_be_healthy",
+        createdAt: "created_at",
+        updatedAt: "updated_at",
+    }))),
+    createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    description: "description",
+    members: "members",
+    createdAt: "created_at",
+    updatedAt: "updated_at",
+}))
+    .pipe(T.ResponsePath("result"));
+export const createMonitorGroup = API.make(() => ({
+    input: CreateMonitorGroupRequest,
+    output: CreateMonitorGroupResponse,
+    errors: [],
+}));
+export const UpdateMonitorGroupRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    monitorGroupId: Schema.String.pipe(T.HttpPath("monitorGroupId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    id: Schema.String,
+    description: Schema.String,
+    members: Schema.Array(Schema.Struct({
+        enabled: Schema.Boolean,
+        monitorId: Schema.String,
+        monitoringOnly: Schema.Boolean,
+        mustBeHealthy: Schema.Boolean,
+    }).pipe(Schema.encodeKeys({
+        enabled: "enabled",
+        monitorId: "monitor_id",
+        monitoringOnly: "monitoring_only",
+        mustBeHealthy: "must_be_healthy",
+    }))),
+}).pipe(T.Http({
+    method: "PUT",
+    path: "/accounts/{account_id}/load_balancers/monitor_groups/{monitorGroupId}",
+}));
+export const UpdateMonitorGroupResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    description: Schema.String,
+    members: Schema.Array(Schema.Struct({
+        enabled: Schema.Boolean,
+        monitorId: Schema.String,
+        monitoringOnly: Schema.Boolean,
+        mustBeHealthy: Schema.Boolean,
+        createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        enabled: "enabled",
+        monitorId: "monitor_id",
+        monitoringOnly: "monitoring_only",
+        mustBeHealthy: "must_be_healthy",
+        createdAt: "created_at",
+        updatedAt: "updated_at",
+    }))),
+    createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    description: "description",
+    members: "members",
+    createdAt: "created_at",
+    updatedAt: "updated_at",
+}))
+    .pipe(T.ResponsePath("result"));
+export const updateMonitorGroup = API.make(() => ({
+    input: UpdateMonitorGroupRequest,
+    output: UpdateMonitorGroupResponse,
+    errors: [],
+}));
+export const PatchMonitorGroupRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    monitorGroupId: Schema.String.pipe(T.HttpPath("monitorGroupId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    id: Schema.String,
+    description: Schema.String,
+    members: Schema.Array(Schema.Struct({
+        enabled: Schema.Boolean,
+        monitorId: Schema.String,
+        monitoringOnly: Schema.Boolean,
+        mustBeHealthy: Schema.Boolean,
+    }).pipe(Schema.encodeKeys({
+        enabled: "enabled",
+        monitorId: "monitor_id",
+        monitoringOnly: "monitoring_only",
+        mustBeHealthy: "must_be_healthy",
+    }))),
+}).pipe(T.Http({
+    method: "PATCH",
+    path: "/accounts/{account_id}/load_balancers/monitor_groups/{monitorGroupId}",
+}));
+export const PatchMonitorGroupResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    description: Schema.String,
+    members: Schema.Array(Schema.Struct({
+        enabled: Schema.Boolean,
+        monitorId: Schema.String,
+        monitoringOnly: Schema.Boolean,
+        mustBeHealthy: Schema.Boolean,
+        createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        enabled: "enabled",
+        monitorId: "monitor_id",
+        monitoringOnly: "monitoring_only",
+        mustBeHealthy: "must_be_healthy",
+        createdAt: "created_at",
+        updatedAt: "updated_at",
+    }))),
+    createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    description: "description",
+    members: "members",
+    createdAt: "created_at",
+    updatedAt: "updated_at",
+}))
+    .pipe(T.ResponsePath("result"));
+export const patchMonitorGroup = API.make(() => ({
+    input: PatchMonitorGroupRequest,
+    output: PatchMonitorGroupResponse,
+    errors: [],
+}));
+export const DeleteMonitorGroupRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    monitorGroupId: Schema.String.pipe(T.HttpPath("monitorGroupId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/load_balancers/monitor_groups/{monitorGroupId}",
+}));
+export const DeleteMonitorGroupResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    description: Schema.String,
+    members: Schema.Array(Schema.Struct({
+        enabled: Schema.Boolean,
+        monitorId: Schema.String,
+        monitoringOnly: Schema.Boolean,
+        mustBeHealthy: Schema.Boolean,
+        createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        enabled: "enabled",
+        monitorId: "monitor_id",
+        monitoringOnly: "monitoring_only",
+        mustBeHealthy: "must_be_healthy",
+        createdAt: "created_at",
+        updatedAt: "updated_at",
+    }))),
+    createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    description: "description",
+    members: "members",
+    createdAt: "created_at",
+    updatedAt: "updated_at",
+}))
+    .pipe(T.ResponsePath("result"));
+export const deleteMonitorGroup = API.make(() => ({
+    input: DeleteMonitorGroupRequest,
+    output: DeleteMonitorGroupResponse,
+    errors: [],
+}));
+export const CreateMonitorPreviewRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    monitorId: Schema.String.pipe(T.HttpPath("monitorId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    allowInsecure: Schema.optional(Schema.Boolean),
+    consecutiveDown: Schema.optional(Schema.Number),
+    consecutiveUp: Schema.optional(Schema.Number),
+    description: Schema.optional(Schema.String),
+    expectedBody: Schema.optional(Schema.String),
+    expectedCodes: Schema.optional(Schema.String),
+    followRedirects: Schema.optional(Schema.Boolean),
+    header: Schema.optional(Schema.Struct({})),
+    interval: Schema.optional(Schema.Number),
+    method: Schema.optional(Schema.String),
+    path: Schema.optional(Schema.String),
+    port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    probeZone: Schema.optional(Schema.String),
+    retries: Schema.optional(Schema.Number),
+    timeout: Schema.optional(Schema.Number),
+    type: Schema.optional(Schema.Literals([
+        "http",
+        "https",
+        "tcp",
+        "udp_icmp",
+        "icmp_ping",
+        "smtp",
+    ])),
+}).pipe(Schema.encodeKeys({
+    allowInsecure: "allow_insecure",
+    consecutiveDown: "consecutive_down",
+    consecutiveUp: "consecutive_up",
+    description: "description",
+    expectedBody: "expected_body",
+    expectedCodes: "expected_codes",
+    followRedirects: "follow_redirects",
+    header: "header",
+    interval: "interval",
+    method: "method",
+    path: "path",
+    port: "port",
+    probeZone: "probe_zone",
+    retries: "retries",
+    timeout: "timeout",
+    type: "type",
+}), T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/load_balancers/monitors/{monitorId}/preview",
+}));
+export const CreateMonitorPreviewResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    pools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    previewId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({ pools: "pools", previewId: "preview_id" }))
+    .pipe(T.ResponsePath("result"));
+export const createMonitorPreview = API.make(() => ({
+    input: CreateMonitorPreviewRequest,
+    output: CreateMonitorPreviewResponse,
+    errors: [],
+}));
+export const GetMonitorReferenceRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    monitorId: Schema.String.pipe(T.HttpPath("monitorId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/load_balancers/monitors/{monitorId}/references",
+}));
+export const GetMonitorReferenceResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        referenceType: Schema.optional(Schema.Union([
+            Schema.Literals(["*", "referral", "referrer"]),
+            Schema.Null,
+        ])),
+        resourceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        resourceName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        resourceType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        referenceType: "reference_type",
+        resourceId: "resource_id",
+        resourceName: "resource_name",
+        resourceType: "resource_type",
+    }))),
+});
+export const getMonitorReference = API.makePaginated(() => ({
+    input: GetMonitorReferenceRequest,
+    output: GetMonitorReferenceResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const GetPoolRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    poolId: Schema.String.pipe(T.HttpPath("poolId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/load_balancers/pools/{poolId}",
+}));
+export const GetPoolResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    checkRegions: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Literals([
+            "WNAM",
+            "ENAM",
+            "WEU",
+            "EEU",
+            "NSAM",
+            "SSAM",
+            "OC",
+            "ME",
+            "NAF",
+            "SAF",
+            "SEAS",
+            "NEAS",
+            "ALL_REGIONS",
+            "SAS",
+        ])),
+        Schema.Null,
+    ])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    disabledAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    latitude: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    loadShedding: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    longitude: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    minimumOrigins: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    monitor: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    monitorGroup: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    networks: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    notificationEmail: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    notificationFilter: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    originSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    origins: Schema.optional(Schema.Union([Schema.Array(Schema.Unknown), Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    checkRegions: "check_regions",
+    createdOn: "created_on",
+    description: "description",
+    disabledAt: "disabled_at",
+    enabled: "enabled",
+    latitude: "latitude",
+    loadShedding: "load_shedding",
+    longitude: "longitude",
+    minimumOrigins: "minimum_origins",
+    modifiedOn: "modified_on",
+    monitor: "monitor",
+    monitorGroup: "monitor_group",
+    name: "name",
+    networks: "networks",
+    notificationEmail: "notification_email",
+    notificationFilter: "notification_filter",
+    originSteering: "origin_steering",
+    origins: "origins",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getPool = API.make(() => ({
+    input: GetPoolRequest,
+    output: GetPoolResponse,
+    errors: [],
+}));
+export const ListPoolsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    monitor: Schema.optional(Schema.String).pipe(T.HttpQuery("monitor")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/load_balancers/pools",
+}));
+export const ListPoolsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        checkRegions: Schema.optional(Schema.Union([
+            Schema.Array(Schema.Literals([
+                "WNAM",
+                "ENAM",
+                "WEU",
+                "EEU",
+                "NSAM",
+                "SSAM",
+                "OC",
+                "ME",
+                "NAF",
+                "SAF",
+                "SEAS",
+                "NEAS",
+                "ALL_REGIONS",
+                "SAS",
+            ])),
+            Schema.Null,
+        ])),
+        createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        disabledAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        latitude: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        loadShedding: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+        longitude: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        minimumOrigins: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        monitor: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        monitorGroup: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        networks: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+        notificationEmail: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        notificationFilter: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+        originSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+        origins: Schema.optional(Schema.Union([Schema.Array(Schema.Unknown), Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        checkRegions: "check_regions",
+        createdOn: "created_on",
+        description: "description",
+        disabledAt: "disabled_at",
+        enabled: "enabled",
+        latitude: "latitude",
+        loadShedding: "load_shedding",
+        longitude: "longitude",
+        minimumOrigins: "minimum_origins",
+        modifiedOn: "modified_on",
+        monitor: "monitor",
+        monitorGroup: "monitor_group",
+        name: "name",
+        networks: "networks",
+        notificationEmail: "notification_email",
+        notificationFilter: "notification_filter",
+        originSteering: "origin_steering",
+        origins: "origins",
+    }))),
+});
+export const listPools = API.makePaginated(() => ({
+    input: ListPoolsRequest,
+    output: ListPoolsResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const CreatePoolRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    name: Schema.String,
+    origins: Schema.Array(Schema.Unknown),
+    description: Schema.optional(Schema.String),
+    enabled: Schema.optional(Schema.Boolean),
+    latitude: Schema.optional(Schema.Number),
+    loadShedding: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    longitude: Schema.optional(Schema.Number),
+    minimumOrigins: Schema.optional(Schema.Number),
+    monitor: Schema.optional(Schema.String),
+    monitorGroup: Schema.optional(Schema.String),
+    notificationEmail: Schema.optional(Schema.String),
+    notificationFilter: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    originSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+}).pipe(Schema.encodeKeys({
+    name: "name",
+    origins: "origins",
+    description: "description",
+    enabled: "enabled",
+    latitude: "latitude",
+    loadShedding: "load_shedding",
+    longitude: "longitude",
+    minimumOrigins: "minimum_origins",
+    monitor: "monitor",
+    monitorGroup: "monitor_group",
+    notificationEmail: "notification_email",
+    notificationFilter: "notification_filter",
+    originSteering: "origin_steering",
+}), T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/load_balancers/pools",
+}));
+export const CreatePoolResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    checkRegions: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Literals([
+            "WNAM",
+            "ENAM",
+            "WEU",
+            "EEU",
+            "NSAM",
+            "SSAM",
+            "OC",
+            "ME",
+            "NAF",
+            "SAF",
+            "SEAS",
+            "NEAS",
+            "ALL_REGIONS",
+            "SAS",
+        ])),
+        Schema.Null,
+    ])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    disabledAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    latitude: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    loadShedding: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    longitude: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    minimumOrigins: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    monitor: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    monitorGroup: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    networks: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    notificationEmail: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    notificationFilter: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    originSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    origins: Schema.optional(Schema.Union([Schema.Array(Schema.Unknown), Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    checkRegions: "check_regions",
+    createdOn: "created_on",
+    description: "description",
+    disabledAt: "disabled_at",
+    enabled: "enabled",
+    latitude: "latitude",
+    loadShedding: "load_shedding",
+    longitude: "longitude",
+    minimumOrigins: "minimum_origins",
+    modifiedOn: "modified_on",
+    monitor: "monitor",
+    monitorGroup: "monitor_group",
+    name: "name",
+    networks: "networks",
+    notificationEmail: "notification_email",
+    notificationFilter: "notification_filter",
+    originSteering: "origin_steering",
+    origins: "origins",
+}))
+    .pipe(T.ResponsePath("result"));
+export const createPool = API.make(() => ({
+    input: CreatePoolRequest,
+    output: CreatePoolResponse,
+    errors: [],
+}));
+export const UpdatePoolRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    poolId: Schema.String.pipe(T.HttpPath("poolId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    name: Schema.String,
+    origins: Schema.Array(Schema.Unknown),
+    checkRegions: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Literals([
+            "WNAM",
+            "ENAM",
+            "WEU",
+            "EEU",
+            "NSAM",
+            "SSAM",
+            "OC",
+            "ME",
+            "NAF",
+            "SAF",
+            "SEAS",
+            "NEAS",
+            "ALL_REGIONS",
+            "SAS",
+        ])),
+        Schema.Null,
+    ])),
+    description: Schema.optional(Schema.String),
+    enabled: Schema.optional(Schema.Boolean),
+    latitude: Schema.optional(Schema.Number),
+    loadShedding: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    longitude: Schema.optional(Schema.Number),
+    minimumOrigins: Schema.optional(Schema.Number),
+    monitor: Schema.optional(Schema.String),
+    monitorGroup: Schema.optional(Schema.String),
+    notificationEmail: Schema.optional(Schema.String),
+    notificationFilter: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    originSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+}).pipe(Schema.encodeKeys({
+    name: "name",
+    origins: "origins",
+    checkRegions: "check_regions",
+    description: "description",
+    enabled: "enabled",
+    latitude: "latitude",
+    loadShedding: "load_shedding",
+    longitude: "longitude",
+    minimumOrigins: "minimum_origins",
+    monitor: "monitor",
+    monitorGroup: "monitor_group",
+    notificationEmail: "notification_email",
+    notificationFilter: "notification_filter",
+    originSteering: "origin_steering",
+}), T.Http({
+    method: "PUT",
+    path: "/accounts/{account_id}/load_balancers/pools/{poolId}",
+}));
+export const UpdatePoolResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    checkRegions: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Literals([
+            "WNAM",
+            "ENAM",
+            "WEU",
+            "EEU",
+            "NSAM",
+            "SSAM",
+            "OC",
+            "ME",
+            "NAF",
+            "SAF",
+            "SEAS",
+            "NEAS",
+            "ALL_REGIONS",
+            "SAS",
+        ])),
+        Schema.Null,
+    ])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    disabledAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    latitude: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    loadShedding: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    longitude: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    minimumOrigins: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    monitor: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    monitorGroup: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    networks: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    notificationEmail: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    notificationFilter: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    originSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    origins: Schema.optional(Schema.Union([Schema.Array(Schema.Unknown), Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    checkRegions: "check_regions",
+    createdOn: "created_on",
+    description: "description",
+    disabledAt: "disabled_at",
+    enabled: "enabled",
+    latitude: "latitude",
+    loadShedding: "load_shedding",
+    longitude: "longitude",
+    minimumOrigins: "minimum_origins",
+    modifiedOn: "modified_on",
+    monitor: "monitor",
+    monitorGroup: "monitor_group",
+    name: "name",
+    networks: "networks",
+    notificationEmail: "notification_email",
+    notificationFilter: "notification_filter",
+    originSteering: "origin_steering",
+    origins: "origins",
+}))
+    .pipe(T.ResponsePath("result"));
+export const updatePool = API.make(() => ({
+    input: UpdatePoolRequest,
+    output: UpdatePoolResponse,
+    errors: [],
+}));
+export const PatchPoolRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    poolId: Schema.String.pipe(T.HttpPath("poolId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    checkRegions: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Literals([
+            "WNAM",
+            "ENAM",
+            "WEU",
+            "EEU",
+            "NSAM",
+            "SSAM",
+            "OC",
+            "ME",
+            "NAF",
+            "SAF",
+            "SEAS",
+            "NEAS",
+            "ALL_REGIONS",
+            "SAS",
+        ])),
+        Schema.Null,
+    ])),
+    description: Schema.optional(Schema.String),
+    enabled: Schema.optional(Schema.Boolean),
+    latitude: Schema.optional(Schema.Number),
+    loadShedding: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    longitude: Schema.optional(Schema.Number),
+    minimumOrigins: Schema.optional(Schema.Number),
+    monitor: Schema.optional(Schema.String),
+    monitorGroup: Schema.optional(Schema.String),
+    name: Schema.optional(Schema.String),
+    notificationEmail: Schema.optional(Schema.String),
+    notificationFilter: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    originSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    origins: Schema.optional(Schema.Array(Schema.Unknown)),
+}).pipe(Schema.encodeKeys({
+    checkRegions: "check_regions",
+    description: "description",
+    enabled: "enabled",
+    latitude: "latitude",
+    loadShedding: "load_shedding",
+    longitude: "longitude",
+    minimumOrigins: "minimum_origins",
+    monitor: "monitor",
+    monitorGroup: "monitor_group",
+    name: "name",
+    notificationEmail: "notification_email",
+    notificationFilter: "notification_filter",
+    originSteering: "origin_steering",
+    origins: "origins",
+}), T.Http({
+    method: "PATCH",
+    path: "/accounts/{account_id}/load_balancers/pools/{poolId}",
+}));
+export const PatchPoolResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    checkRegions: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Literals([
+            "WNAM",
+            "ENAM",
+            "WEU",
+            "EEU",
+            "NSAM",
+            "SSAM",
+            "OC",
+            "ME",
+            "NAF",
+            "SAF",
+            "SEAS",
+            "NEAS",
+            "ALL_REGIONS",
+            "SAS",
+        ])),
+        Schema.Null,
+    ])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    disabledAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    latitude: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    loadShedding: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    longitude: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    minimumOrigins: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    monitor: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    monitorGroup: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    networks: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    notificationEmail: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    notificationFilter: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    originSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+    origins: Schema.optional(Schema.Union([Schema.Array(Schema.Unknown), Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    checkRegions: "check_regions",
+    createdOn: "created_on",
+    description: "description",
+    disabledAt: "disabled_at",
+    enabled: "enabled",
+    latitude: "latitude",
+    loadShedding: "load_shedding",
+    longitude: "longitude",
+    minimumOrigins: "minimum_origins",
+    modifiedOn: "modified_on",
+    monitor: "monitor",
+    monitorGroup: "monitor_group",
+    name: "name",
+    networks: "networks",
+    notificationEmail: "notification_email",
+    notificationFilter: "notification_filter",
+    originSteering: "origin_steering",
+    origins: "origins",
+}))
+    .pipe(T.ResponsePath("result"));
+export const patchPool = API.make(() => ({
+    input: PatchPoolRequest,
+    output: PatchPoolResponse,
+    errors: [],
+}));
+export const DeletePoolRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    poolId: Schema.String.pipe(T.HttpPath("poolId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/load_balancers/pools/{poolId}",
+}));
+export const DeletePoolResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}).pipe(T.ResponsePath("result"));
+export const deletePool = API.make(() => ({
+    input: DeletePoolRequest,
+    output: DeletePoolResponse,
+    errors: [],
+}));
+export const BulkPatchPoolsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    notificationEmail: Schema.optional(Schema.Literal("")),
+}).pipe(Schema.encodeKeys({ notificationEmail: "notification_email" }), T.Http({
+    method: "PATCH",
+    path: "/accounts/{account_id}/load_balancers/pools",
+}));
+export const BulkPatchPoolsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        checkRegions: Schema.optional(Schema.Union([
+            Schema.Array(Schema.Literals([
+                "WNAM",
+                "ENAM",
+                "WEU",
+                "EEU",
+                "NSAM",
+                "SSAM",
+                "OC",
+                "ME",
+                "NAF",
+                "SAF",
+                "SEAS",
+                "NEAS",
+                "ALL_REGIONS",
+                "SAS",
+            ])),
+            Schema.Null,
+        ])),
+        createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        disabledAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        latitude: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        loadShedding: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+        longitude: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        minimumOrigins: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        monitor: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        monitorGroup: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        networks: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+        notificationEmail: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        notificationFilter: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+        originSteering: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+        origins: Schema.optional(Schema.Union([Schema.Array(Schema.Unknown), Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        checkRegions: "check_regions",
+        createdOn: "created_on",
+        description: "description",
+        disabledAt: "disabled_at",
+        enabled: "enabled",
+        latitude: "latitude",
+        loadShedding: "load_shedding",
+        longitude: "longitude",
+        minimumOrigins: "minimum_origins",
+        modifiedOn: "modified_on",
+        monitor: "monitor",
+        monitorGroup: "monitor_group",
+        name: "name",
+        networks: "networks",
+        notificationEmail: "notification_email",
+        notificationFilter: "notification_filter",
+        originSteering: "origin_steering",
+        origins: "origins",
+    }))),
+});
+export const bulkPatchPools = API.makePaginated(() => ({
+    input: BulkPatchPoolsRequest,
+    output: BulkPatchPoolsResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const GetPoolHealthRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    poolId: Schema.String.pipe(T.HttpPath("poolId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/load_balancers/pools/{poolId}/health",
+}));
+export const GetPoolHealthResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    poolId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    popHealth: Schema.optional(Schema.Union([
+        Schema.Struct({
+            healthy: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            origins: Schema.optional(Schema.Union([
+                Schema.Array(Schema.Struct({
+                    ip: Schema.optional(Schema.Union([
+                        Schema.Struct({
+                            failureReason: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            healthy: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            responseCode: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                            rtt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            failureReason: "failure_reason",
+                            healthy: "healthy",
+                            responseCode: "response_code",
+                            rtt: "rtt",
+                        })),
+                        Schema.Null,
+                    ])),
+                })),
+                Schema.Null,
+            ])),
+        }),
+        Schema.Null,
+    ])),
+})
+    .pipe(Schema.encodeKeys({ poolId: "pool_id", popHealth: "pop_health" }))
+    .pipe(T.ResponsePath("result"));
+export const getPoolHealth = API.make(() => ({
+    input: GetPoolHealthRequest,
+    output: GetPoolHealthResponse,
+    errors: [],
+}));
+export const CreatePoolHealthRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    poolId: Schema.String.pipe(T.HttpPath("poolId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    allowInsecure: Schema.optional(Schema.Boolean),
+    consecutiveDown: Schema.optional(Schema.Number),
+    consecutiveUp: Schema.optional(Schema.Number),
+    description: Schema.optional(Schema.String),
+    expectedBody: Schema.optional(Schema.String),
+    expectedCodes: Schema.optional(Schema.String),
+    followRedirects: Schema.optional(Schema.Boolean),
+    header: Schema.optional(Schema.Struct({})),
+    interval: Schema.optional(Schema.Number),
+    method: Schema.optional(Schema.String),
+    path: Schema.optional(Schema.String),
+    port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    probeZone: Schema.optional(Schema.String),
+    retries: Schema.optional(Schema.Number),
+    timeout: Schema.optional(Schema.Number),
+    type: Schema.optional(Schema.Literals([
+        "http",
+        "https",
+        "tcp",
+        "udp_icmp",
+        "icmp_ping",
+        "smtp",
+    ])),
+}).pipe(Schema.encodeKeys({
+    allowInsecure: "allow_insecure",
+    consecutiveDown: "consecutive_down",
+    consecutiveUp: "consecutive_up",
+    description: "description",
+    expectedBody: "expected_body",
+    expectedCodes: "expected_codes",
+    followRedirects: "follow_redirects",
+    header: "header",
+    interval: "interval",
+    method: "method",
+    path: "path",
+    port: "port",
+    probeZone: "probe_zone",
+    retries: "retries",
+    timeout: "timeout",
+    type: "type",
+}), T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/load_balancers/pools/{poolId}/preview",
+}));
+export const CreatePoolHealthResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    pools: Schema.optional(Schema.Union([Schema.Struct({}), Schema.Null])),
+    previewId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({ pools: "pools", previewId: "preview_id" }))
+    .pipe(T.ResponsePath("result"));
+export const createPoolHealth = API.make(() => ({
+    input: CreatePoolHealthRequest,
+    output: CreatePoolHealthResponse,
+    errors: [],
+}));
+export const GetPoolReferenceRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    poolId: Schema.String.pipe(T.HttpPath("poolId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/load_balancers/pools/{poolId}/references",
+}));
+export const GetPoolReferenceResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        referenceType: Schema.optional(Schema.Union([
+            Schema.Literals(["*", "referral", "referrer"]),
+            Schema.Null,
+        ])),
+        resourceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        resourceName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        resourceType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        referenceType: "reference_type",
+        resourceId: "resource_id",
+        resourceName: "resource_name",
+        resourceType: "resource_type",
+    }))),
+});
+export const getPoolReference = API.makePaginated(() => ({
+    input: GetPoolReferenceRequest,
+    output: GetPoolReferenceResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const GetPreviewRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    previewId: Schema.String.pipe(T.HttpPath("previewId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/load_balancers/preview/{previewId}",
+}));
+export const GetPreviewResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(T.ResponsePath("result"));
+export const getPreview = API.make(() => ({
+    input: GetPreviewRequest,
+    output: GetPreviewResponse,
+    errors: [],
+}));
+export const GetRegionRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    regionId: Schema.Literals([
+        "WNAM",
+        "ENAM",
+        "WEU",
+        "EEU",
+        "NSAM",
+        "SSAM",
+        "OC",
+        "ME",
+        "NAF",
+        "SAF",
+        "SAS",
+        "SEAS",
+        "NEAS",
+    ]).pipe(T.HttpPath("regionId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/load_balancers/regions/{regionId}",
+}));
+export const GetRegionResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Union([
+    Schema.String,
+    Schema.Null,
+]).pipe(T.ResponsePath("result"));
+export const getRegion = API.make(() => ({
+    input: GetRegionRequest,
+    output: GetRegionResponse,
+    errors: [],
+}));
+export const ListRegionsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    countryCodeA2: Schema.optional(Schema.String).pipe(T.HttpQuery("country_code_a2")),
+    subdivisionCode: Schema.optional(Schema.String).pipe(T.HttpQuery("subdivision_code")),
+    subdivisionCodeA2: Schema.optional(Schema.String).pipe(T.HttpQuery("subdivision_code_a2")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/load_balancers/regions",
+}));
+export const ListRegionsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Union([
+    Schema.String,
+    Schema.Null,
+]).pipe(T.ResponsePath("result"));
+export const listRegions = API.make(() => ({
+    input: ListRegionsRequest,
+    output: ListRegionsResponse,
+    errors: [],
+}));
+export const ListSearchesRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    query: Schema.optional(Schema.String).pipe(T.HttpQuery("query")),
+    references: Schema.optional(Schema.Literals(["", "*", "referral", "referrer"])).pipe(T.HttpQuery("references")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/load_balancers/search",
+}));
+export const ListSearchesResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Struct({
+        items: Schema.optional(Schema.Union([
+            Schema.Array(Schema.Struct({
+                resources: Schema.optional(Schema.Union([
+                    Schema.Array(Schema.Struct({
+                        referenceType: Schema.optional(Schema.Union([
+                            Schema.Literals(["referral", "referrer"]),
+                            Schema.Null,
+                        ])),
+                        references: Schema.optional(Schema.Union([Schema.Array(Schema.Unknown), Schema.Null])),
+                        resourceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        resourceName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        resourceType: Schema.optional(Schema.Union([
+                            Schema.Literals(["load_balancer", "monitor", "pool"]),
+                            Schema.Null,
+                        ])),
+                    }).pipe(Schema.encodeKeys({
+                        referenceType: "reference_type",
+                        references: "references",
+                        resourceId: "resource_id",
+                        resourceName: "resource_name",
+                        resourceType: "resource_type",
+                    }))),
+                    Schema.Null,
+                ])),
+            })),
+            Schema.Null,
+        ])),
+    }),
+    resultInfo: Schema.Struct({
+        count: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        page: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        perPage: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        totalCount: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        count: "count",
+        page: "page",
+        perPage: "per_page",
+        totalCount: "total_count",
+    })),
+}).pipe(Schema.encodeKeys({ result: "result", resultInfo: "result_info" }));
+export const listSearches = API.makePaginated(() => ({
+    input: ListSearchesRequest,
+    output: ListSearchesResponse,
+    errors: [],
+    pagination: {
+        mode: "page",
+        inputToken: "page",
+        outputToken: "resultInfo.page",
+        items: "result.items",
+        pageSize: "perPage",
+    },
+}));
+//# sourceMappingURL=load-balancers.js.map