@distilled.cloud/stackit 0.0.0-placeholder → 1.0.0-rc.13

package/src/services/load_balancer.ts

@@ -0,0 +1,1342 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-stackit). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import * as C from "@distilled.cloud/core/category";
+import * as T from "../traits.ts";
+import {
+  StackitProtocol,
+  type StackitOpError,
+  type StackitOpContext,
+} from "../protocol.ts";
+import { UnknownStackitError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { StackitOpError, StackitOpContext };
+
+export class BadRequest
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<BadRequest>()("BadRequest", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 400 }],
+  ) {}
+
+export class Conflict
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<Conflict>()("Conflict", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withConflictError),
+    [{ status: 409 }],
+  ) {}
+
+export class Forbidden
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<Forbidden>()("Forbidden", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withAuthError),
+    [{ status: 403 }],
+  ) {}
+
+export class NotFound
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<NotFound>()("NotFound", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 404 }],
+  ) {}
+
+export interface CreateCredentialsRequest {
+  projectId: string;
+  region: string;
+  /** Credential name */
+  displayName?: string;
+  /** A valid password used for an existing STACKIT Observability instance, which is used during basic auth. */
+  password?: string | Redacted.Redacted<string>;
+  /** A valid username used for an existing STACKIT Observability instance, which is used during basic auth. */
+  username?: string;
+}
+export const CreateCredentialsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    displayName: S.optional(S.String),
+    password: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    username: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{region}/credentials",
+      code: 200,
+      baseUrl: "https://load-balancer.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "CreateCredentialsRequest",
+}) as any as S.Schema<CreateCredentialsRequest>;
+
+export interface CredentialsResponse {
+  /** The credentials reference can be used for observability of the Load Balancer. */
+  credentialsRef?: string;
+  /** Credential name */
+  displayName?: string;
+  /** Region of the Credential */
+  region?: string;
+  /** The username used for the STACKIT Observability instance */
+  username?: string;
+}
+export const CredentialsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    credentialsRef: S.optional(S.String),
+    displayName: S.optional(S.String),
+    region: S.optional(S.String),
+    username: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "CredentialsResponse",
+}) as any as S.Schema<CredentialsResponse>;
+
+export interface CreateCredentialsResponse {
+  credential?: CredentialsResponse;
+}
+export const CreateCredentialsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    credential: S.optional(CredentialsResponse),
+  }),
+).annotate({
+  identifier: "CreateCredentialsResponse",
+}) as any as S.Schema<CreateCredentialsResponse>;
+
+/** Labels represent user-defined metadata as key-value pairs. Label count should not exceed 64 per LB. **Key Formatting Rules:** Length: 1-63 characters. Characters: Must begin and end with [a-zA-Z0-9]. May contain dashes (-), underscores (_), dots (.), and alphanumerics in between. Keys starting with 'stackit-' are system-reserved; users MUST NOT manage them. **Value Formatting Rules:** Length: 0-63 characters (empty string explicitly allowed). Characters (for non-empty values): Must begin and end with [a-zA-Z0-9]. May contain dashes (-), underscores (_), dots (.), and alphanumerics in between. */
+export type CreateLoadBalancerRequestLabelsMap = {
+  [key: string]: string | undefined;
+};
+export const CreateLoadBalancerRequestLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<CreateLoadBalancerRequestLabelsMap>;
+
+/** Protocol is the highest network protocol we understand to load balance. Currently only PROTOCOL_TCP, PROTOCOL_TCP_PROXY and PROTOCOL_TLS_PASSTHROUGH are supported. */
+export type ListenerInputProtocol =
+  | "PROTOCOL_UNSPECIFIED"
+  | "PROTOCOL_TCP"
+  | "PROTOCOL_UDP"
+  | "PROTOCOL_TCP_PROXY"
+  | "PROTOCOL_TLS_PASSTHROUGH";
+export const ListenerInputProtocol = /*@__PURE__*/ S.String;
+
+export interface ServerNameIndicator {
+  /** The domain name for this SNI config. */
+  name?: string;
+}
+export const ServerNameIndicator = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ServerNameIndicator",
+}) as any as S.Schema<ServerNameIndicator>;
+
+/** Server Name Indicators config for domains to be routed to the desired target pool for this listener. */
+export type ListenerInputServerNameIndicatorsList = Array<ServerNameIndicator>;
+export const ListenerInputServerNameIndicatorsList = /*@__PURE__*/ S.Array(
+  ServerNameIndicator,
+) as any as S.Schema<ListenerInputServerNameIndicatorsList>;
+
+/** ProtocolOptionsTCP options to be configured for the PROTOCOL_TCP, PROTOCOL_TCP_PROXY, and PROTOCOL_TLS_PASSTHROUGH protocols. TCP options for the SNI listeners with the same port must be the same. */
+export interface OptionsTCP {
+  /** The connection idle timeout to be used with the protocol. The default value is set to 5 minutes, and the maximum value is one hour. */
+  idleTimeout?: string;
+}
+export const OptionsTCP = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    idleTimeout: S.optional(S.String),
+  }),
+).annotate({ identifier: "OptionsTCP" }) as any as S.Schema<OptionsTCP>;
+
+/** ProtocolOptionsUDP options to be configured for the PROTOCOL_UDP protocol. */
+export interface OptionsUDP {
+  /** The connection idle timeout to be used with the protocol. The default value is set to 1 minute, and the maximum value is 2 minutes. */
+  idleTimeout?: string;
+}
+export const OptionsUDP = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    idleTimeout: S.optional(S.String),
+  }),
+).annotate({ identifier: "OptionsUDP" }) as any as S.Schema<OptionsUDP>;
+
+export interface ListenerInput {
+  displayName?: string;
+  /** Port number where we listen for traffic */
+  port?: number;
+  /** Protocol is the highest network protocol we understand to load balance. Currently only PROTOCOL_TCP, PROTOCOL_TCP_PROXY and PROTOCOL_TLS_PASSTHROUGH are supported. */
+  protocol?: ListenerInputProtocol | (string & {});
+  /** Server Name Indicators config for domains to be routed to the desired target pool for this listener. */
+  serverNameIndicators?: ListenerInputServerNameIndicatorsList;
+  /** Reference target pool by target pool name. */
+  targetPool?: string;
+  tcp?: OptionsTCP;
+  udp?: OptionsUDP;
+}
+export const ListenerInput = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    displayName: S.optional(S.String),
+    port: S.optional(S.Number),
+    protocol: S.optional(ListenerInputProtocol),
+    serverNameIndicators: S.optional(ListenerInputServerNameIndicatorsList),
+    targetPool: S.optional(S.String),
+    tcp: S.optional(OptionsTCP),
+    udp: S.optional(OptionsUDP),
+  }),
+).annotate({ identifier: "ListenerInput" }) as any as S.Schema<ListenerInput>;
+
+/** There is a maximum listener count of 20. Port and protocol limitations: - UDP listeners cannot have the same port. - TCP-derived listeners cannot have the same port. A TCP-derived listener is any listener that listens on a TCP port. As of now those are: TCP, TCP_PROXY, and PROTOCOL_TLS_PASSTHROUGH. The only exception is, if all listeners for the same port are PROTOCOL_TLS_PASSTHROUGH. - PROTOCOL_TLS_PASSTHROUGH listeners cannot have the same port and at least one common domain name. - PROTOCOL_TLS_PASSTHROUGH listeners can have the same domain name and different ports though (e.g. ports 443 and 8443 for domain example.com). - PROTOCOL_TLS_PASSTHROUGH listeners without a domain name serve as a default listener and you can have only one default listener. */
+export type CreateLoadBalancerRequestListenersList = Array<ListenerInput>;
+export const CreateLoadBalancerRequestListenersList = /*@__PURE__*/ S.Array(
+  ListenerInput,
+) as any as S.Schema<CreateLoadBalancerRequestListenersList>;
+
+/** The role defines how the load balancer is using the network. Currently only ROLE_LISTENERS_AND_TARGETS is supported. */
+export type NetworkRole =
+  | "ROLE_UNSPECIFIED"
+  | "ROLE_LISTENERS_AND_TARGETS"
+  | "ROLE_LISTENERS"
+  | "ROLE_TARGETS";
+export const NetworkRole = /*@__PURE__*/ S.String;
+
+export interface Network {
+  /** Openstack network ID */
+  networkId?: string;
+  /** The role defines how the load balancer is using the network. Currently only ROLE_LISTENERS_AND_TARGETS is supported. */
+  role?: NetworkRole | (string & {});
+}
+export const Network = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    networkId: S.optional(S.String),
+    role: S.optional(NetworkRole),
+  }),
+).annotate({ identifier: "Network" }) as any as S.Schema<Network>;
+
+/** List of networks that listeners and targets reside in. Currently limited to one. Not changeable after creation. */
+export type CreateLoadBalancerRequestNetworksList = Array<Network>;
+export const CreateLoadBalancerRequestNetworksList = /*@__PURE__*/ S.Array(
+  Network,
+) as any as S.Schema<CreateLoadBalancerRequestNetworksList>;
+
+/** Load Balancer is accessible only from an IP address in this range */
+export type LoadbalancerOptionAccessControlAllowedSourceRangesList =
+  Array<string>;
+export const LoadbalancerOptionAccessControlAllowedSourceRangesList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<LoadbalancerOptionAccessControlAllowedSourceRangesList>;
+
+/** Use this option to limit the IP ranges that can use the load balancer. */
+export interface LoadbalancerOptionAccessControl {
+  /** Load Balancer is accessible only from an IP address in this range */
+  allowedSourceRanges?: LoadbalancerOptionAccessControlAllowedSourceRangesList;
+}
+export const LoadbalancerOptionAccessControl = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allowedSourceRanges: S.optional(
+      LoadbalancerOptionAccessControlAllowedSourceRangesList,
+    ),
+  }),
+).annotate({
+  identifier: "LoadbalancerOptionAccessControl",
+}) as any as S.Schema<LoadbalancerOptionAccessControl>;
+
+export interface LoadbalancerOptionLogs {
+  /** Credentials reference for logging. This reference is created via the observability create endpoint and the credential needs to contain the basic auth username and password for the logging solution the push URL points to. Then this enables monitoring via remote write for the Load Balancer. */
+  credentialsRef?: string;
+  /** The Observability(Logs)/Loki remote write Push URL you want the logs to be shipped to. */
+  pushUrl?: string;
+}
+export const LoadbalancerOptionLogs = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    credentialsRef: S.optional(S.String),
+    pushUrl: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "LoadbalancerOptionLogs",
+}) as any as S.Schema<LoadbalancerOptionLogs>;
+
+export interface LoadbalancerOptionMetrics {
+  /** Credentials reference for metrics. This reference is created via the observability create endpoint and the credential needs to contain the basic auth username and password for the metrics solution the push URL points to. Then this enables monitoring via remote write for the Load Balancer. */
+  credentialsRef?: string;
+  /** The Observability(Metrics)/Prometheus remote write push URL you want the metrics to be shipped to. */
+  pushUrl?: string;
+}
+export const LoadbalancerOptionMetrics = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    credentialsRef: S.optional(S.String),
+    pushUrl: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "LoadbalancerOptionMetrics",
+}) as any as S.Schema<LoadbalancerOptionMetrics>;
+
+/** We offer Load Balancer observability via STACKIT Observability or external solutions. */
+export interface LoadbalancerOptionObservability {
+  logs?: LoadbalancerOptionLogs;
+  metrics?: LoadbalancerOptionMetrics;
+}
+export const LoadbalancerOptionObservability = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    logs: S.optional(LoadbalancerOptionLogs),
+    metrics: S.optional(LoadbalancerOptionMetrics),
+  }),
+).annotate({
+  identifier: "LoadbalancerOptionObservability",
+}) as any as S.Schema<LoadbalancerOptionObservability>;
+
+/** Defines any optional functionality you want to have enabled on your load balancer. */
+export interface LoadBalancerOptions {
+  accessControl?: LoadbalancerOptionAccessControl;
+  ephemeralAddress?: boolean;
+  observability?: LoadbalancerOptionObservability;
+  /** Load Balancer is accessible only via a private network ip address. Not changeable after creation. */
+  privateNetworkOnly?: boolean;
+}
+export const LoadBalancerOptions = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    accessControl: S.optional(LoadbalancerOptionAccessControl),
+    ephemeralAddress: S.optional(S.Boolean),
+    observability: S.optional(LoadbalancerOptionObservability),
+    privateNetworkOnly: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "LoadBalancerOptions",
+}) as any as S.Schema<LoadBalancerOptions>;
+
+/** List of HTTP status codes that indicate a healthy response */
+export type HttpHealthChecksOkStatusesList = Array<string>;
+export const HttpHealthChecksOkStatusesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<HttpHealthChecksOkStatusesList>;
+
+/** Set this to configure TLS settings. */
+export interface TlsConfig {
+  /** Specifies a custom Certificate Authority (CA). When provided, the target pool will trust certificates signed by this CA, in addition to any system-trusted CAs. This is useful for scenarios where the target pool needs to communicate with servers using self-signed or internally-issued certificates. Enabled needs to be set to true and skip validation to false for this option. */
+  customCa?: string;
+  /** Enable TLS (Transport Layer Security) bridging for the connection between Application Load Balancer and targets in this pool. When enabled, public CAs are trusted. Can be used in tandem with the options either custom CA or skip validation or alone. */
+  enabled?: boolean;
+  /** Bypass certificate validation for TLS bridging in this target pool. This option is insecure and can only be used with public CAs by setting enabled true. Meant to be used for testing purposes only! */
+  skipCertificateValidation?: boolean;
+}
+export const TlsConfig = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    customCa: S.optional(S.String),
+    enabled: S.optional(S.Boolean),
+    skipCertificateValidation: S.optional(S.Boolean),
+  }),
+).annotate({ identifier: "TlsConfig" }) as any as S.Schema<TlsConfig>;
+
+/** Options for the HTTP health checking. */
+export interface HttpHealthChecks {
+  /** List of HTTP status codes that indicate a healthy response */
+  okStatuses?: HttpHealthChecksOkStatusesList;
+  /** Path to send the health check request to */
+  path?: string;
+  tls?: TlsConfig;
+}
+export const HttpHealthChecks = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    okStatuses: S.optional(HttpHealthChecksOkStatusesList),
+    path: S.optional(S.String),
+    tls: S.optional(TlsConfig),
+  }),
+).annotate({
+  identifier: "HttpHealthChecks",
+}) as any as S.Schema<HttpHealthChecks>;
+
+export interface ActiveHealthCheck {
+  /** Overrides the default port used for health check probes. */
+  altPort?: number;
+  /** Healthy threshold of the health checking */
+  healthyThreshold?: number;
+  httpHealthChecks?: HttpHealthChecks;
+  /** Interval duration of health checking in seconds */
+  interval?: string;
+  /** Interval duration threshold of the health checking in seconds */
+  intervalJitter?: string;
+  /** Active health checking timeout duration in seconds */
+  timeout?: string;
+  /** Unhealthy threshold of the health checking */
+  unhealthyThreshold?: number;
+}
+export const ActiveHealthCheck = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    altPort: S.optional(S.Number),
+    healthyThreshold: S.optional(S.Number),
+    httpHealthChecks: S.optional(HttpHealthChecks),
+    interval: S.optional(S.String),
+    intervalJitter: S.optional(S.String),
+    timeout: S.optional(S.String),
+    unhealthyThreshold: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "ActiveHealthCheck",
+}) as any as S.Schema<ActiveHealthCheck>;
+
+export interface SessionPersistence {
+  /** If enabled then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. */
+  useSourceIpAddress?: boolean;
+}
+export const SessionPersistence = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    useSourceIpAddress: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "SessionPersistence",
+}) as any as S.Schema<SessionPersistence>;
+
+export interface Target {
+  /** Target name */
+  displayName?: string;
+  /** Target IP. Must by unique within a target pool. */
+  ip?: string;
+}
+export const Target = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    displayName: S.optional(S.String),
+    ip: S.optional(S.String),
+  }),
+).annotate({ identifier: "Target" }) as any as S.Schema<Target>;
+
+/** List of all targets which will be used in the pool. Limited to 250. */
+export type TargetPoolTargetsList = Array<Target>;
+export const TargetPoolTargetsList = /*@__PURE__*/ S.Array(
+  Target,
+) as any as S.Schema<TargetPoolTargetsList>;
+
+export interface TargetPool {
+  activeHealthCheck?: ActiveHealthCheck;
+  /** Target pool name */
+  name?: string;
+  sessionPersistence?: SessionPersistence;
+  /** The number identifying the port where each target listens for traffic. */
+  targetPort?: number;
+  /** List of all targets which will be used in the pool. Limited to 250. */
+  targets?: TargetPoolTargetsList;
+}
+export const TargetPool = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    activeHealthCheck: S.optional(ActiveHealthCheck),
+    name: S.optional(S.String),
+    sessionPersistence: S.optional(SessionPersistence),
+    targetPort: S.optional(S.Number),
+    targets: S.optional(TargetPoolTargetsList),
+  }),
+).annotate({ identifier: "TargetPool" }) as any as S.Schema<TargetPool>;
+
+/** List of all target pools which will be used in the load balancer. Limited to 20. */
+export type CreateLoadBalancerRequestTargetPoolsList = Array<TargetPool>;
+export const CreateLoadBalancerRequestTargetPoolsList = /*@__PURE__*/ S.Array(
+  TargetPool,
+) as any as S.Schema<CreateLoadBalancerRequestTargetPoolsList>;
+
+export interface CreateLoadBalancerRequest {
+  projectId: string;
+  region: string;
+  /** Disable target security group assignemt to allow targets outside of the given network. Connectivity to targets need to be ensured by the customer, including routing and Security Groups (targetSecurityGroup can be assigned). Not changeable after creation. */
+  disableTargetSecurityGroupAssignment?: boolean;
+  /** External load balancer IP address where this load balancer is exposed. Not changeable after creation. */
+  externalAddress?: string;
+  /** Labels represent user-defined metadata as key-value pairs. Label count should not exceed 64 per LB. **Key Formatting Rules:** Length: 1-63 characters. Characters: Must begin and end with [a-zA-Z0-9]. May contain dashes (-), underscores (_), dots (.), and alphanumerics in between. Keys starting with 'stackit-' are system-reserved; users MUST NOT manage them. **Value Formatting Rules:** Length: 0-63 characters (empty string explicitly allowed). Characters (for non-empty values): Must begin and end with [a-zA-Z0-9]. May contain dashes (-), underscores (_), dots (.), and alphanumerics in between. */
+  labels?: CreateLoadBalancerRequestLabelsMap;
+  /** There is a maximum listener count of 20. Port and protocol limitations: - UDP listeners cannot have the same port. - TCP-derived listeners cannot have the same port. A TCP-derived listener is any listener that listens on a TCP port. As of now those are: TCP, TCP_PROXY, and PROTOCOL_TLS_PASSTHROUGH. The only exception is, if all listeners for the same port are PROTOCOL_TLS_PASSTHROUGH. - PROTOCOL_TLS_PASSTHROUGH listeners cannot have the same port and at least one common domain name. - PROTOCOL_TLS_PASSTHROUGH listeners can have the same domain name and different ports though (e.g. ports 443 and 8443 for domain example.com). - PROTOCOL_TLS_PASSTHROUGH listeners without a domain name serve as a default listener and you can have only one default listener. */
+  listeners?: CreateLoadBalancerRequestListenersList;
+  /** Load balancer name. Not changeable after creation. */
+  name?: string;
+  /** List of networks that listeners and targets reside in. Currently limited to one. Not changeable after creation. */
+  networks?: CreateLoadBalancerRequestNetworksList;
+  options?: LoadBalancerOptions;
+  /** Service Plan configures the size of the Load Balancer. Currently supported plans are p10, p50, p250 and p750. This list can change in the future where plan ids will be removed and new plans by added. That is the reason this is not an enum. */
+  planId?: string;
+  /** List of all target pools which will be used in the load balancer. Limited to 20. */
+  targetPools?: CreateLoadBalancerRequestTargetPoolsList;
+  /** Load balancer resource version. Must be empty or unset for creating load balancers, non-empty for updating load balancers. Semantics: While retrieving load balancers, this is the current version of this load balancer resource that changes during updates of the load balancers. On updates this field specified the load balancer version you calculated your update for instead of the future version to enable concurrency safe updates. Update calls will then report the new version in their result as you would see with a load balancer retrieval call later. There exist no total order of the version, so you can only compare it for equality, but not for less/greater than another version. Since the creation of load balancer is always intended to create the first version of it, there should be no existing version. That's why this field must by empty of not present in that case. */
+  version?: string;
+}
+export const CreateLoadBalancerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    disableTargetSecurityGroupAssignment: S.optional(S.Boolean),
+    externalAddress: S.optional(S.String),
+    labels: S.optional(CreateLoadBalancerRequestLabelsMap),
+    listeners: S.optional(CreateLoadBalancerRequestListenersList),
+    name: S.optional(S.String),
+    networks: S.optional(CreateLoadBalancerRequestNetworksList),
+    options: S.optional(LoadBalancerOptions),
+    planId: S.optional(S.String),
+    targetPools: S.optional(CreateLoadBalancerRequestTargetPoolsList),
+    version: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{region}/load-balancers",
+      code: 200,
+      baseUrl: "https://load-balancer.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "CreateLoadBalancerRequest",
+}) as any as S.Schema<CreateLoadBalancerRequest>;
+
+/** The error type specifies which part of the load balancer encountered the error. I.e. the API will not check if a provided public IP is actually available in the project. Instead the load balancer with try to use the provided IP and if not available reports TYPE_FIP_NOT_CONFIGURED error or TYPE_FIP_NOT_FOUND if the IP was deleted. */
+export type LoadBalancerErrorType =
+  | "TYPE_UNSPECIFIED"
+  | "TYPE_INTERNAL"
+  | "TYPE_QUOTA_SECGROUP_EXCEEDED"
+  | "TYPE_QUOTA_SECGROUPRULE_EXCEEDED"
+  | "TYPE_PORT_NOT_CONFIGURED"
+  | "TYPE_FIP_NOT_CONFIGURED"
+  | "TYPE_TARGET_NOT_ACTIVE"
+  | "TYPE_METRICS_MISCONFIGURED"
+  | "TYPE_LOGS_MISCONFIGURED"
+  | "TYPE_FIP_NOT_FOUND"
+  | "TYPE_IP_EXHAUSTED"
+  | "TYPE_DNS_NOT_CONFIGURED"
+  | "TYPE_VM_PORT_NOT_CONFIGURED";
+export const LoadBalancerErrorType = /*@__PURE__*/ S.String;
+
+export interface LoadBalancerError {
+  /** The error description contains additional helpful user information to fix the error state of the load balancer. For example the IP 45.135.247.139 does not exist in the project, then the description will report: Floating IP "45.135.247.139" could not be found or if the IP was deleted then you will get a proper error message. */
+  description?: string;
+  /** The error type specifies which part of the load balancer encountered the error. I.e. the API will not check if a provided public IP is actually available in the project. Instead the load balancer with try to use the provided IP and if not available reports TYPE_FIP_NOT_CONFIGURED error or TYPE_FIP_NOT_FOUND if the IP was deleted. */
+  type?: LoadBalancerErrorType;
+}
+export const LoadBalancerError = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    type: S.optional(LoadBalancerErrorType),
+  }),
+).annotate({
+  identifier: "LoadBalancerError",
+}) as any as S.Schema<LoadBalancerError>;
+
+/** Reports all errors a load balancer has. */
+export type LoadBalancerErrorsList = Array<LoadBalancerError>;
+export const LoadBalancerErrorsList = /*@__PURE__*/ S.Array(
+  LoadBalancerError,
+) as any as S.Schema<LoadBalancerErrorsList>;
+
+/** Labels represent user-defined metadata as key-value pairs. Label count should not exceed 64 per LB. **Key Formatting Rules:** Length: 1-63 characters. Characters: Must begin and end with [a-zA-Z0-9]. May contain dashes (-), underscores (_), dots (.), and alphanumerics in between. Keys starting with 'stackit-' are system-reserved; users MUST NOT manage them. **Value Formatting Rules:** Length: 0-63 characters (empty string explicitly allowed). Characters (for non-empty values): Must begin and end with [a-zA-Z0-9]. May contain dashes (-), underscores (_), dots (.), and alphanumerics in between. */
+export type LoadBalancerLabelsMap = { [key: string]: string | undefined };
+export const LoadBalancerLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<LoadBalancerLabelsMap>;
+
+/** Protocol is the highest network protocol we understand to load balance. Currently only PROTOCOL_TCP, PROTOCOL_TCP_PROXY and PROTOCOL_TLS_PASSTHROUGH are supported. */
+export type ListenerProtocol =
+  | "PROTOCOL_UNSPECIFIED"
+  | "PROTOCOL_TCP"
+  | "PROTOCOL_UDP"
+  | "PROTOCOL_TCP_PROXY"
+  | "PROTOCOL_TLS_PASSTHROUGH";
+export const ListenerProtocol = /*@__PURE__*/ S.String;
+
+/** Server Name Indicators config for domains to be routed to the desired target pool for this listener. */
+export type ListenerServerNameIndicatorsList = Array<ServerNameIndicator>;
+export const ListenerServerNameIndicatorsList = /*@__PURE__*/ S.Array(
+  ServerNameIndicator,
+) as any as S.Schema<ListenerServerNameIndicatorsList>;
+
+export interface Listener {
+  displayName?: string;
+  /** Will be used to reference a listener and will replace display name in the future. Currently uses <protocol>-<port> as the name if no display name is given. */
+  name?: string;
+  /** Port number where we listen for traffic */
+  port?: number;
+  /** Protocol is the highest network protocol we understand to load balance. Currently only PROTOCOL_TCP, PROTOCOL_TCP_PROXY and PROTOCOL_TLS_PASSTHROUGH are supported. */
+  protocol?: ListenerProtocol;
+  /** Server Name Indicators config for domains to be routed to the desired target pool for this listener. */
+  serverNameIndicators?: ListenerServerNameIndicatorsList;
+  /** Reference target pool by target pool name. */
+  targetPool?: string;
+  tcp?: OptionsTCP;
+  udp?: OptionsUDP;
+}
+export const Listener = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    displayName: S.optional(S.String),
+    name: S.optional(S.String),
+    port: S.optional(S.Number),
+    protocol: S.optional(ListenerProtocol),
+    serverNameIndicators: S.optional(ListenerServerNameIndicatorsList),
+    targetPool: S.optional(S.String),
+    tcp: S.optional(OptionsTCP),
+    udp: S.optional(OptionsUDP),
+  }),
+).annotate({ identifier: "Listener" }) as any as S.Schema<Listener>;
+
+/** There is a maximum listener count of 20. Port and protocol limitations: - UDP listeners cannot have the same port. - TCP-derived listeners cannot have the same port. A TCP-derived listener is any listener that listens on a TCP port. As of now those are: TCP, TCP_PROXY, and PROTOCOL_TLS_PASSTHROUGH. The only exception is, if all listeners for the same port are PROTOCOL_TLS_PASSTHROUGH. - PROTOCOL_TLS_PASSTHROUGH listeners cannot have the same port and at least one common domain name. - PROTOCOL_TLS_PASSTHROUGH listeners can have the same domain name and different ports though (e.g. ports 443 and 8443 for domain example.com). - PROTOCOL_TLS_PASSTHROUGH listeners without a domain name serve as a default listener and you can have only one default listener. */
+export type LoadBalancerListenersList = Array<Listener>;
+export const LoadBalancerListenersList = /*@__PURE__*/ S.Array(
+  Listener,
+) as any as S.Schema<LoadBalancerListenersList>;
+
+export interface SecurityGroup {
+  /** ID of the security Group */
+  id?: string;
+  /** Name of the security Group */
+  name?: string;
+}
+export const SecurityGroup = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.String),
+    name: S.optional(S.String),
+  }),
+).annotate({ identifier: "SecurityGroup" }) as any as S.Schema<SecurityGroup>;
+
+/** List of networks that listeners and targets reside in. Currently limited to one. Not changeable after creation. */
+export type LoadBalancerNetworksList = Array<Network>;
+export const LoadBalancerNetworksList = /*@__PURE__*/ S.Array(
+  Network,
+) as any as S.Schema<LoadBalancerNetworksList>;
+
+export type LoadBalancerStatus =
+  | "STATUS_UNSPECIFIED"
+  | "STATUS_PENDING"
+  | "STATUS_READY"
+  | "STATUS_ERROR"
+  | "STATUS_TERMINATING";
+export const LoadBalancerStatus = /*@__PURE__*/ S.String;
+
+/** List of all target pools which will be used in the load balancer. Limited to 20. */
+export type LoadBalancerTargetPoolsList = Array<TargetPool>;
+export const LoadBalancerTargetPoolsList = /*@__PURE__*/ S.Array(
+  TargetPool,
+) as any as S.Schema<LoadBalancerTargetPoolsList>;
+
+export interface LoadBalancer2 {
+  /** Disable target security group assignemt to allow targets outside of the given network. Connectivity to targets need to be ensured by the customer, including routing and Security Groups (targetSecurityGroup can be assigned). Not changeable after creation. */
+  disableTargetSecurityGroupAssignment?: boolean;
+  /** Reports all errors a load balancer has. */
+  errors?: LoadBalancerErrorsList;
+  /** External load balancer IP address where this load balancer is exposed. Not changeable after creation. */
+  externalAddress?: string;
+  /** Labels represent user-defined metadata as key-value pairs. Label count should not exceed 64 per LB. **Key Formatting Rules:** Length: 1-63 characters. Characters: Must begin and end with [a-zA-Z0-9]. May contain dashes (-), underscores (_), dots (.), and alphanumerics in between. Keys starting with 'stackit-' are system-reserved; users MUST NOT manage them. **Value Formatting Rules:** Length: 0-63 characters (empty string explicitly allowed). Characters (for non-empty values): Must begin and end with [a-zA-Z0-9]. May contain dashes (-), underscores (_), dots (.), and alphanumerics in between. */
+  labels?: LoadBalancerLabelsMap;
+  /** There is a maximum listener count of 20. Port and protocol limitations: - UDP listeners cannot have the same port. - TCP-derived listeners cannot have the same port. A TCP-derived listener is any listener that listens on a TCP port. As of now those are: TCP, TCP_PROXY, and PROTOCOL_TLS_PASSTHROUGH. The only exception is, if all listeners for the same port are PROTOCOL_TLS_PASSTHROUGH. - PROTOCOL_TLS_PASSTHROUGH listeners cannot have the same port and at least one common domain name. - PROTOCOL_TLS_PASSTHROUGH listeners can have the same domain name and different ports though (e.g. ports 443 and 8443 for domain example.com). - PROTOCOL_TLS_PASSTHROUGH listeners without a domain name serve as a default listener and you can have only one default listener. */
+  listeners?: LoadBalancerListenersList;
+  /** Security Group permitting network traffic from the LoadBalancer to the targets. Useful when disableTargetSecurityGroupAssignment=true to manually assign target security groups to targets. */
+  loadBalancerSecurityGroup?: SecurityGroup;
+  /** Load balancer name. Not changeable after creation. */
+  name?: string;
+  /** List of networks that listeners and targets reside in. Currently limited to one. Not changeable after creation. */
+  networks?: LoadBalancerNetworksList;
+  options?: LoadBalancerOptions;
+  /** Service Plan configures the size of the Load Balancer. Currently supported plans are p10, p50, p250 and p750. This list can change in the future where plan ids will be removed and new plans by added. That is the reason this is not an enum. */
+  planId?: string;
+  /** Transient private load balancer IP address that can change any time. */
+  privateAddress?: string;
+  /** Region of the LoadBalancer */
+  region?: string;
+  status?: LoadBalancerStatus;
+  /** List of all target pools which will be used in the load balancer. Limited to 20. */
+  targetPools?: LoadBalancerTargetPoolsList;
+  /** Security Group that allows the targets to receive traffic from the LoadBalancer. Useful when disableTargetSecurityGroupAssignment=true to manually assign target security groups to targets. */
+  targetSecurityGroup?: SecurityGroup;
+  /** Load balancer resource version. Must be empty or unset for creating load balancers, non-empty for updating load balancers. Semantics: While retrieving load balancers, this is the current version of this load balancer resource that changes during updates of the load balancers. On updates this field specified the load balancer version you calculated your update for instead of the future version to enable concurrency safe updates. Update calls will then report the new version in their result as you would see with a load balancer retrieval call later. There exist no total order of the version, so you can only compare it for equality, but not for less/greater than another version. Since the creation of load balancer is always intended to create the first version of it, there should be no existing version. That's why this field must by empty of not present in that case. */
+  version?: string;
+}
+export const LoadBalancer2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    disableTargetSecurityGroupAssignment: S.optional(S.Boolean),
+    errors: S.optional(LoadBalancerErrorsList),
+    externalAddress: S.optional(S.String),
+    labels: S.optional(LoadBalancerLabelsMap),
+    listeners: S.optional(LoadBalancerListenersList),
+    loadBalancerSecurityGroup: S.optional(SecurityGroup),
+    name: S.optional(S.String),
+    networks: S.optional(LoadBalancerNetworksList),
+    options: S.optional(LoadBalancerOptions),
+    planId: S.optional(S.String),
+    privateAddress: S.optional(S.String),
+    region: S.optional(S.String),
+    status: S.optional(LoadBalancerStatus),
+    targetPools: S.optional(LoadBalancerTargetPoolsList),
+    targetSecurityGroup: S.optional(SecurityGroup),
+    version: S.optional(S.String),
+  }),
+).annotate({ identifier: "LoadBalancer2" }) as any as S.Schema<LoadBalancer2>;
+
+export interface DeleteCredentialsRequest {
+  projectId: string;
+  region: string;
+  credentialsRef: string;
+}
+export const DeleteCredentialsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    credentialsRef: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v2/projects/{projectId}/regions/{region}/credentials/{credentialsRef}",
+      code: 200,
+      baseUrl: "https://load-balancer.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "DeleteCredentialsRequest",
+}) as any as S.Schema<DeleteCredentialsRequest>;
+
+export type DeleteCredentialsResponse2 = unknown;
+export const DeleteCredentialsResponse2 = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DeleteCredentialsResponse2",
+}) as any as S.Schema<DeleteCredentialsResponse2>;
+
+export interface DeleteLoadBalancerRequest {
+  projectId: string;
+  region: string;
+  name: string;
+}
+export const DeleteLoadBalancerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v2/projects/{projectId}/regions/{region}/load-balancers/{name}",
+      code: 200,
+      baseUrl: "https://load-balancer.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "DeleteLoadBalancerRequest",
+}) as any as S.Schema<DeleteLoadBalancerRequest>;
+
+export type DeleteLoadBalancerResponse2 = unknown;
+export const DeleteLoadBalancerResponse2 = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DeleteLoadBalancerResponse2",
+}) as any as S.Schema<DeleteLoadBalancerResponse2>;
+
+export interface GetCredentialsRequest {
+  projectId: string;
+  region: string;
+  credentialsRef: string;
+}
+export const GetCredentialsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    credentialsRef: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/credentials/{credentialsRef}",
+      code: 200,
+      baseUrl: "https://load-balancer.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "GetCredentialsRequest",
+}) as any as S.Schema<GetCredentialsRequest>;
+
+export interface GetCredentialsResponse {
+  credential?: CredentialsResponse;
+}
+export const GetCredentialsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    credential: S.optional(CredentialsResponse),
+  }),
+).annotate({
+  identifier: "GetCredentialsResponse",
+}) as any as S.Schema<GetCredentialsResponse>;
+
+export interface GetLoadBalancerRequest {
+  projectId: string;
+  region: string;
+  name: string;
+}
+export const GetLoadBalancerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/load-balancers/{name}",
+      code: 200,
+      baseUrl: "https://load-balancer.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "GetLoadBalancerRequest",
+}) as any as S.Schema<GetLoadBalancerRequest>;
+
+export interface GetQuotaRequest {
+  projectId: string;
+  region: string;
+}
+export const GetQuotaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/quota",
+      code: 200,
+      baseUrl: "https://load-balancer.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "GetQuotaRequest",
+}) as any as S.Schema<GetQuotaRequest>;
+
+export interface GetQuotaResponse {
+  /** The maximum number of observability credentials that can be stored in this project. */
+  maxCredentials?: number;
+  /** The maximum number of load balancing servers in this project. */
+  maxLoadBalancers?: number;
+  /** Project identifier */
+  projectId?: string;
+  /** Region */
+  region?: string;
+  /** The number of observability credentials that are currently existing in this project. */
+  usedCredentials?: number;
+  /** The number of load balancing servers that are currently existing in this project. */
+  usedLoadBalancers?: number;
+}
+export const GetQuotaResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    maxCredentials: S.optional(S.Number),
+    maxLoadBalancers: S.optional(S.Number),
+    projectId: S.optional(S.String),
+    region: S.optional(S.String),
+    usedCredentials: S.optional(S.Number),
+    usedLoadBalancers: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "GetQuotaResponse",
+}) as any as S.Schema<GetQuotaResponse>;
+
+export interface ListCredentialsRequest {
+  projectId: string;
+  region: string;
+}
+export const ListCredentialsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/credentials",
+      code: 200,
+      baseUrl: "https://load-balancer.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "ListCredentialsRequest",
+}) as any as S.Schema<ListCredentialsRequest>;
+
+export type ListCredentialsResponseCredentialsList = Array<CredentialsResponse>;
+export const ListCredentialsResponseCredentialsList = /*@__PURE__*/ S.Array(
+  CredentialsResponse,
+) as any as S.Schema<ListCredentialsResponseCredentialsList>;
+
+export interface ListCredentialsResponse {
+  credentials?: ListCredentialsResponseCredentialsList;
+}
+export const ListCredentialsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    credentials: S.optional(ListCredentialsResponseCredentialsList),
+  }),
+).annotate({
+  identifier: "ListCredentialsResponse",
+}) as any as S.Schema<ListCredentialsResponse>;
+
+export interface ListLoadBalancersRequest {
+  projectId: string;
+  region: string;
+  /** page_size specifies how many load balancers should be returned on this page. Must be a positive number <= 1000 */
+  pageSize?: string;
+  /** page_id is a page identifier returned by the previous response and is used to request the next page */
+  pageId?: string;
+}
+export const ListLoadBalancersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    pageSize: S.optional(S.String.pipe(T.Query())),
+    pageId: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/load-balancers",
+      code: 200,
+      baseUrl: "https://load-balancer.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "ListLoadBalancersRequest",
+}) as any as S.Schema<ListLoadBalancersRequest>;
+
+export type ListLoadBalancersResponseLoadBalancersList = Array<LoadBalancer2>;
+export const ListLoadBalancersResponseLoadBalancersList = /*@__PURE__*/ S.Array(
+  LoadBalancer2,
+) as any as S.Schema<ListLoadBalancersResponseLoadBalancersList>;
+
+export interface ListLoadBalancersResponse {
+  loadBalancers?: ListLoadBalancersResponseLoadBalancersList;
+  /** Continue token from the ListLoadBalancerResponse with Limit option */
+  nextPageId?: string;
+}
+export const ListLoadBalancersResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    loadBalancers: S.optional(ListLoadBalancersResponseLoadBalancersList),
+    nextPageId: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ListLoadBalancersResponse",
+}) as any as S.Schema<ListLoadBalancersResponse>;
+
+export interface ListPlansRequest {
+  region: string;
+}
+export const ListPlansRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    region: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/regions/{region}/plans",
+      code: 200,
+      baseUrl: "https://load-balancer.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "ListPlansRequest",
+}) as any as S.Schema<ListPlansRequest>;
+
+export interface PlanDetails {
+  /** Description */
+  description?: string;
+  /** Flavor Name */
+  flavorName?: string;
+  /** Maximum number of concurrent connections per load balancer VM instance. */
+  maxConnections?: number;
+  /** Service Plan Name */
+  name?: string;
+  /** Service Plan Identifier */
+  planId?: string;
+  /** Region this Plan is available in */
+  region?: string;
+}
+export const PlanDetails = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    flavorName: S.optional(S.String),
+    maxConnections: S.optional(S.Number),
+    name: S.optional(S.String),
+    planId: S.optional(S.String),
+    region: S.optional(S.String),
+  }),
+).annotate({ identifier: "PlanDetails" }) as any as S.Schema<PlanDetails>;
+
+export type ListPlansResponseValidPlansList = Array<PlanDetails>;
+export const ListPlansResponseValidPlansList = /*@__PURE__*/ S.Array(
+  PlanDetails,
+) as any as S.Schema<ListPlansResponseValidPlansList>;
+
+export interface ListPlansResponse {
+  validPlans?: ListPlansResponseValidPlansList;
+}
+export const ListPlansResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    validPlans: S.optional(ListPlansResponseValidPlansList),
+  }),
+).annotate({
+  identifier: "ListPlansResponse",
+}) as any as S.Schema<ListPlansResponse>;
+
+export interface UpdateCredentialsRequest {
+  projectId: string;
+  region: string;
+  credentialsRef: string;
+  /** Credential name */
+  displayName?: string;
+  /** A valid password used for an existing STACKIT Observability instance, which is used during basic auth. */
+  password?: string | Redacted.Redacted<string>;
+  /** A valid username used for an existing STACKIT Observability instance, which is used during basic auth. */
+  username?: string;
+}
+export const UpdateCredentialsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    credentialsRef: S.String.pipe(T.Label()),
+    displayName: S.optional(S.String),
+    password: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    username: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/v2/projects/{projectId}/regions/{region}/credentials/{credentialsRef}",
+      code: 200,
+      baseUrl: "https://load-balancer.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "UpdateCredentialsRequest",
+}) as any as S.Schema<UpdateCredentialsRequest>;
+
+export interface UpdateCredentialsResponse {
+  credential?: CredentialsResponse;
+}
+export const UpdateCredentialsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    credential: S.optional(CredentialsResponse),
+  }),
+).annotate({
+  identifier: "UpdateCredentialsResponse",
+}) as any as S.Schema<UpdateCredentialsResponse>;
+
+/** Labels represent user-defined metadata as key-value pairs. Label count should not exceed 64 per LB. **Key Formatting Rules:** Length: 1-63 characters. Characters: Must begin and end with [a-zA-Z0-9]. May contain dashes (-), underscores (_), dots (.), and alphanumerics in between. Keys starting with 'stackit-' are system-reserved; users MUST NOT manage them. **Value Formatting Rules:** Length: 0-63 characters (empty string explicitly allowed). Characters (for non-empty values): Must begin and end with [a-zA-Z0-9]. May contain dashes (-), underscores (_), dots (.), and alphanumerics in between. */
+export type UpdateLoadBalancerRequestLabelsMap = {
+  [key: string]: string | undefined;
+};
+export const UpdateLoadBalancerRequestLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<UpdateLoadBalancerRequestLabelsMap>;
+
+/** There is a maximum listener count of 20. Port and protocol limitations: - UDP listeners cannot have the same port. - TCP-derived listeners cannot have the same port. A TCP-derived listener is any listener that listens on a TCP port. As of now those are: TCP, TCP_PROXY, and PROTOCOL_TLS_PASSTHROUGH. The only exception is, if all listeners for the same port are PROTOCOL_TLS_PASSTHROUGH. - PROTOCOL_TLS_PASSTHROUGH listeners cannot have the same port and at least one common domain name. - PROTOCOL_TLS_PASSTHROUGH listeners can have the same domain name and different ports though (e.g. ports 443 and 8443 for domain example.com). - PROTOCOL_TLS_PASSTHROUGH listeners without a domain name serve as a default listener and you can have only one default listener. */
+export type UpdateLoadBalancerRequestListenersList = Array<ListenerInput>;
+export const UpdateLoadBalancerRequestListenersList = /*@__PURE__*/ S.Array(
+  ListenerInput,
+) as any as S.Schema<UpdateLoadBalancerRequestListenersList>;
+
+/** List of networks that listeners and targets reside in. Currently limited to one. Not changeable after creation. */
+export type UpdateLoadBalancerRequestNetworksList = Array<Network>;
+export const UpdateLoadBalancerRequestNetworksList = /*@__PURE__*/ S.Array(
+  Network,
+) as any as S.Schema<UpdateLoadBalancerRequestNetworksList>;
+
+/** List of all target pools which will be used in the load balancer. Limited to 20. */
+export type UpdateLoadBalancerRequestTargetPoolsList = Array<TargetPool>;
+export const UpdateLoadBalancerRequestTargetPoolsList = /*@__PURE__*/ S.Array(
+  TargetPool,
+) as any as S.Schema<UpdateLoadBalancerRequestTargetPoolsList>;
+
+export interface UpdateLoadBalancerRequest {
+  projectId: string;
+  region: string;
+  name: string;
+  /** Disable target security group assignemt to allow targets outside of the given network. Connectivity to targets need to be ensured by the customer, including routing and Security Groups (targetSecurityGroup can be assigned). Not changeable after creation. */
+  disableTargetSecurityGroupAssignment?: boolean;
+  /** External load balancer IP address where this load balancer is exposed. Not changeable after creation. */
+  externalAddress?: string;
+  /** Labels represent user-defined metadata as key-value pairs. Label count should not exceed 64 per LB. **Key Formatting Rules:** Length: 1-63 characters. Characters: Must begin and end with [a-zA-Z0-9]. May contain dashes (-), underscores (_), dots (.), and alphanumerics in between. Keys starting with 'stackit-' are system-reserved; users MUST NOT manage them. **Value Formatting Rules:** Length: 0-63 characters (empty string explicitly allowed). Characters (for non-empty values): Must begin and end with [a-zA-Z0-9]. May contain dashes (-), underscores (_), dots (.), and alphanumerics in between. */
+  labels?: UpdateLoadBalancerRequestLabelsMap;
+  /** There is a maximum listener count of 20. Port and protocol limitations: - UDP listeners cannot have the same port. - TCP-derived listeners cannot have the same port. A TCP-derived listener is any listener that listens on a TCP port. As of now those are: TCP, TCP_PROXY, and PROTOCOL_TLS_PASSTHROUGH. The only exception is, if all listeners for the same port are PROTOCOL_TLS_PASSTHROUGH. - PROTOCOL_TLS_PASSTHROUGH listeners cannot have the same port and at least one common domain name. - PROTOCOL_TLS_PASSTHROUGH listeners can have the same domain name and different ports though (e.g. ports 443 and 8443 for domain example.com). - PROTOCOL_TLS_PASSTHROUGH listeners without a domain name serve as a default listener and you can have only one default listener. */
+  listeners?: UpdateLoadBalancerRequestListenersList;
+  /** List of networks that listeners and targets reside in. Currently limited to one. Not changeable after creation. */
+  networks?: UpdateLoadBalancerRequestNetworksList;
+  options?: LoadBalancerOptions;
+  /** Service Plan configures the size of the Load Balancer. Currently supported plans are p10, p50, p250 and p750. This list can change in the future where plan ids will be removed and new plans by added. That is the reason this is not an enum. */
+  planId?: string;
+  /** List of all target pools which will be used in the load balancer. Limited to 20. */
+  targetPools?: UpdateLoadBalancerRequestTargetPoolsList;
+  /** Load balancer resource version. Must be empty or unset for creating load balancers, non-empty for updating load balancers. Semantics: While retrieving load balancers, this is the current version of this load balancer resource that changes during updates of the load balancers. On updates this field specified the load balancer version you calculated your update for instead of the future version to enable concurrency safe updates. Update calls will then report the new version in their result as you would see with a load balancer retrieval call later. There exist no total order of the version, so you can only compare it for equality, but not for less/greater than another version. Since the creation of load balancer is always intended to create the first version of it, there should be no existing version. That's why this field must by empty of not present in that case. */
+  version?: string;
+}
+export const UpdateLoadBalancerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+    disableTargetSecurityGroupAssignment: S.optional(S.Boolean),
+    externalAddress: S.optional(S.String),
+    labels: S.optional(UpdateLoadBalancerRequestLabelsMap),
+    listeners: S.optional(UpdateLoadBalancerRequestListenersList),
+    networks: S.optional(UpdateLoadBalancerRequestNetworksList),
+    options: S.optional(LoadBalancerOptions),
+    planId: S.optional(S.String),
+    targetPools: S.optional(UpdateLoadBalancerRequestTargetPoolsList),
+    version: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/v2/projects/{projectId}/regions/{region}/load-balancers/{name}",
+      code: 200,
+      baseUrl: "https://load-balancer.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "UpdateLoadBalancerRequest",
+}) as any as S.Schema<UpdateLoadBalancerRequest>;
+
+/** List of all targets which will be used in the pool. Limited to 250. */
+export type UpdateTargetPoolRequestTargetsList = Array<Target>;
+export const UpdateTargetPoolRequestTargetsList = /*@__PURE__*/ S.Array(
+  Target,
+) as any as S.Schema<UpdateTargetPoolRequestTargetsList>;
+
+export interface UpdateTargetPoolRequest {
+  projectId: string;
+  region: string;
+  name: string;
+  targetPoolName: string;
+  activeHealthCheck?: ActiveHealthCheck;
+  sessionPersistence?: SessionPersistence;
+  /** The number identifying the port where each target listens for traffic. */
+  targetPort?: number;
+  /** List of all targets which will be used in the pool. Limited to 250. */
+  targets?: UpdateTargetPoolRequestTargetsList;
+}
+export const UpdateTargetPoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+    targetPoolName: S.String.pipe(T.Label()),
+    activeHealthCheck: S.optional(ActiveHealthCheck),
+    sessionPersistence: S.optional(SessionPersistence),
+    targetPort: S.optional(S.Number),
+    targets: S.optional(UpdateTargetPoolRequestTargetsList),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/v2/projects/{projectId}/regions/{region}/load-balancers/{name}/target-pools/{targetPoolName}",
+      code: 200,
+      baseUrl: "https://load-balancer.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "UpdateTargetPoolRequest",
+}) as any as S.Schema<UpdateTargetPoolRequest>;
+
+export type CreateCredentialsError = BadRequest | Forbidden | StackitOpError;
+/** Create credentials for observability of the Load Balancer Created credentials can be stored and used for the load balancer observability. For example, when using STACKIT Observability, credentials first must be created for that STACKIT Observability instance (by using their API or the STACKIT Portal) and then can be provided to the load balancer by storing them with this endpoint. */
+export const createCredentials: API.OperationMethod<
+  CreateCredentialsRequest,
+  CreateCredentialsResponse,
+  CreateCredentialsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateCredentialsRequest,
+  output: CreateCredentialsResponse,
+  errors: [BadRequest, Forbidden, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateLoadBalancerError =
+  | BadRequest
+  | Forbidden
+  | Conflict
+  | StackitOpError;
+/** Create a load balancer in a project Create Load Balancer will create a load balancer. The default load balancing algorithm is round robin unless useSourceIpAddress in session persistence is enabled for a target pool then it is Maglev. */
+export const createLoadBalancer: API.OperationMethod<
+  CreateLoadBalancerRequest,
+  LoadBalancer2,
+  CreateLoadBalancerError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateLoadBalancerRequest,
+  output: LoadBalancer2,
+  errors: [BadRequest, Forbidden, Conflict, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteCredentialsError = BadRequest | Forbidden | StackitOpError;
+/** Delete a single credential in a project. Delete Credential */
+export const deleteCredentials: API.OperationMethod<
+  DeleteCredentialsRequest,
+  DeleteCredentialsResponse2,
+  DeleteCredentialsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteCredentialsRequest,
+  output: DeleteCredentialsResponse2,
+  errors: [BadRequest, Forbidden, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteLoadBalancerError = BadRequest | Forbidden | StackitOpError;
+/** Delete a given load balancer in a project. DeleteLoadBalancer will delete a given load balancer. */
+export const deleteLoadBalancer: API.OperationMethod<
+  DeleteLoadBalancerRequest,
+  DeleteLoadBalancerResponse2,
+  DeleteLoadBalancerError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteLoadBalancerRequest,
+  output: DeleteLoadBalancerResponse2,
+  errors: [BadRequest, Forbidden, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetCredentialsError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | StackitOpError;
+/** Get a single credential reference in a project. Get Credentials */
+export const getCredentials: API.OperationMethod<
+  GetCredentialsRequest,
+  GetCredentialsResponse,
+  GetCredentialsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetCredentialsRequest,
+  output: GetCredentialsResponse,
+  errors: [BadRequest, Forbidden, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetLoadBalancerError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | StackitOpError;
+/** Get a single load balancer in a project. Get Load Balancer will get a single load balancer of a project. This contains all the information set during creation or updates. Additionally, it will have information about the state of the load balancer in the form of a status field and error description feedback. */
+export const getLoadBalancer: API.OperationMethod<
+  GetLoadBalancerRequest,
+  LoadBalancer2,
+  GetLoadBalancerError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetLoadBalancerRequest,
+  output: LoadBalancer2,
+  errors: [BadRequest, Forbidden, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetQuotaError = BadRequest | Forbidden | StackitOpError;
+/** Get the quota of Network Load Balancers in a project. Retrieves the configured Network Load Balancer quota for the project. Limit can be changed via service request. */
+export const getQuota: API.OperationMethod<
+  GetQuotaRequest,
+  GetQuotaResponse,
+  GetQuotaError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetQuotaRequest,
+  output: GetQuotaResponse,
+  errors: [BadRequest, Forbidden, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListCredentialsError = BadRequest | Forbidden | StackitOpError;
+/** List all credentials in a project. List Credentials */
+export const listCredentials: API.OperationMethod<
+  ListCredentialsRequest,
+  ListCredentialsResponse,
+  ListCredentialsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListCredentialsRequest,
+  output: ListCredentialsResponse,
+  errors: [BadRequest, Forbidden, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListLoadBalancersError = BadRequest | Forbidden | StackitOpError;
+/** List load balancers in a project. ListLoadBalancer will list load balancers of a project. This contains information set during creation or updates for every load balancer in the project. Additionally, it will have information about the state of the load balancer in the form of a status field and error description feedback. */
+export const listLoadBalancers: API.OperationMethod<
+  ListLoadBalancersRequest,
+  ListLoadBalancersResponse,
+  ListLoadBalancersError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListLoadBalancersRequest,
+  output: ListLoadBalancersResponse,
+  errors: [BadRequest, Forbidden, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListPlansError = BadRequest | Forbidden | StackitOpError;
+/** List available service plans. ListPlans returns for the configured service plans for a project. */
+export const listPlans: API.OperationMethod<
+  ListPlansRequest,
+  ListPlansResponse,
+  ListPlansError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListPlansRequest,
+  output: ListPlansResponse,
+  errors: [BadRequest, Forbidden, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateCredentialsError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | StackitOpError;
+/** Update credentials for observability in a project. Update Credentials */
+export const updateCredentials: API.OperationMethod<
+  UpdateCredentialsRequest,
+  UpdateCredentialsResponse,
+  UpdateCredentialsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateCredentialsRequest,
+  output: UpdateCredentialsResponse,
+  errors: [BadRequest, Forbidden, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateLoadBalancerError =
+  | BadRequest
+  | Forbidden
+  | Conflict
+  | StackitOpError;
+/** Update a load balancer in a project. Update Load Balancer allows the change of listeners and target pools of an existing Load Balancer. The Load balancer resource version needs to be the current version to ensure concurrency safe updates. The default load balancing algorithm is round robin unless useSourceIpAddress in session persistence is enabled for a target pool then it is Maglev. */
+export const updateLoadBalancer: API.OperationMethod<
+  UpdateLoadBalancerRequest,
+  LoadBalancer2,
+  UpdateLoadBalancerError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateLoadBalancerRequest,
+  output: LoadBalancer2,
+  errors: [BadRequest, Forbidden, Conflict, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateTargetPoolError = BadRequest | Forbidden | StackitOpError;
+/** Update a single target pool of a load balancer in a project. ReplaceTargetPool will replace a specific target pool of a load balancer with new content. Useful to add/remove target servers. will update a load balancer. Only replaces the mentioned target pools and leaves others unchanged. Cannot be used to create or rename a target pool. */
+export const updateTargetPool: API.OperationMethod<
+  UpdateTargetPoolRequest,
+  TargetPool,
+  UpdateTargetPoolError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateTargetPoolRequest,
+  output: TargetPool,
+  errors: [BadRequest, Forbidden, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));