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

package/lib/services/alb.d.ts

@@ -0,0 +1,603 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import { type StackitOpError, type StackitOpContext } from "../protocol.ts";
+export type { StackitOpError, StackitOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const Conflict_base: S.Class<Conflict, S.TaggedStruct<"Conflict", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+export declare class Conflict extends /*@__PURE__*/ Conflict_base {
+}
+declare const Forbidden_base: S.Class<Forbidden, S.TaggedStruct<"Forbidden", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        AuthError: true;
+    };
+});
+export declare class Forbidden extends /*@__PURE__*/ Forbidden_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+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 declare const CreateCredentialsRequest: S.Schema<CreateCredentialsRequest>;
+export interface CredentialsResponse {
+    /** The credentials reference can be used for observability of the Application 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 declare const CredentialsResponse: S.Schema<CredentialsResponse>;
+export interface CreateCredentialsResponse {
+    credential?: CredentialsResponse;
+}
+export declare const CreateCredentialsResponse: S.Schema<CreateCredentialsResponse>;
+/** Labels represent user-defined metadata as key-value pairs. Label count should not exceed 64 per ALB. **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 declare const CreateLoadBalancerRequestLabelsMap: S.Schema<CreateLoadBalancerRequestLabelsMap>;
+/** CookiePersistence contains the cookie-based session persistence configuration. */
+export interface CookiePersistence {
+    /** Cookie is the name of the cookie to use. */
+    name?: string;
+    /** TTL specifies the time-to-live for the cookie. The default value is 0s, and it acts as a session cookie, expiring when the client session ends. */
+    ttl?: string;
+}
+export declare const CookiePersistence: S.Schema<CookiePersistence>;
+export interface HttpHeader {
+    /** Exact match for the header value. */
+    exactMatch?: string;
+    /** Header name. */
+    name?: string;
+}
+export declare const HttpHeader: S.Schema<HttpHeader>;
+/** Headers for the rule. */
+export type RuleHeadersList = Array<HttpHeader>;
+export declare const RuleHeadersList: S.Schema<RuleHeadersList>;
+/** Path match. Optional. Contains either an exact or prefix match. If not set, defaults to root path '/' of prefix type. Cannot be set if 'path_prefix' is used. Prefer using this field over 'path_prefix'. */
+export interface Path {
+    /** Exact path match. Only a request path exactly equal to the value will match, e.g. '/foo' matches only '/foo', not '/foo/bar' or '/foobar'. */
+    exactMatch?: string;
+    /** Prefix path match. Only matches on full segment boundaries, e.g. '/foo' matches '/foo' and '/foo/bar' but NOT '/foobar'. */
+    prefix?: string;
+}
+export declare const Path: S.Schema<Path>;
+export interface QueryParameter {
+    /** Exact match for the parameter value. */
+    exactMatch?: string;
+    /** Parameter name. */
+    name?: string;
+}
+export declare const QueryParameter: S.Schema<QueryParameter>;
+/** Query parameters for the rule. */
+export type RuleQueryParametersList = Array<QueryParameter>;
+export declare const RuleQueryParametersList: S.Schema<RuleQueryParametersList>;
+export interface Rule {
+    cookiePersistence?: CookiePersistence;
+    /** Headers for the rule. */
+    headers?: RuleHeadersList;
+    path?: Path;
+    /** Query parameters for the rule. */
+    queryParameters?: RuleQueryParametersList;
+    /** Reference target pool by target pool name. */
+    targetPool?: string;
+    /** If enabled, when client sends an HTTP request with and Upgrade header, indicating the desire to establish a Websocket connection, if backend server supports WebSocket, it responds with HTTP 101 status code, switching protocols from HTTP to WebSocket. Hence the client and the server can exchange data in real-time using one long-lived TCP connection. */
+    webSocket?: boolean;
+}
+export declare const Rule: S.Schema<Rule>;
+/** Routing rules under the specified host, matched by path prefix. */
+export type HostConfigRulesList = Array<Rule>;
+export declare const HostConfigRulesList: S.Schema<HostConfigRulesList>;
+export interface HostConfig {
+    /** Hostname to match. Supports wildcards (e.g. *.example.com). */
+    host?: string;
+    /** Routing rules under the specified host, matched by path prefix. */
+    rules?: HostConfigRulesList;
+}
+export declare const HostConfig: S.Schema<HostConfig>;
+/** Defines routing rules grouped by hostname. */
+export type ProtocolOptionsHTTPHostsList = Array<HostConfig>;
+export declare const ProtocolOptionsHTTPHostsList: S.Schema<ProtocolOptionsHTTPHostsList>;
+/** Configuration for handling HTTP traffic on this listener. */
+export interface ProtocolOptionsHTTP {
+    /** Defines routing rules grouped by hostname. */
+    hosts?: ProtocolOptionsHTTPHostsList;
+}
+export declare const ProtocolOptionsHTTP: S.Schema<ProtocolOptionsHTTP>;
+/** Certificate IDs for TLS termination. */
+export type CertificateConfigCertificateIdsList = Array<string>;
+export declare const CertificateConfigCertificateIdsList: S.Schema<CertificateConfigCertificateIdsList>;
+/** TLS termination certificate configuration. */
+export interface CertificateConfig {
+    /** Certificate IDs for TLS termination. */
+    certificateIds?: CertificateConfigCertificateIdsList;
+}
+export declare const CertificateConfig: S.Schema<CertificateConfig>;
+/** Configuration for handling HTTPS traffic on this listener. */
+export interface ProtocolOptionsHTTPS {
+    certificateConfig?: CertificateConfig;
+}
+export declare const ProtocolOptionsHTTPS: S.Schema<ProtocolOptionsHTTPS>;
+/** Protocol is the highest network protocol we understand to load balance. Currently PROTOCOL_HTTP and PROTOCOL_HTTPS are supported. */
+export type ListenerProtocol = "PROTOCOL_UNSPECIFIED" | "PROTOCOL_HTTP" | "PROTOCOL_HTTPS";
+export declare const ListenerProtocol: any;
+export interface Listener {
+    http?: ProtocolOptionsHTTP;
+    https?: ProtocolOptionsHTTPS;
+    /** A unique listener name. */
+    name?: string;
+    /** Port number on which the listener receives incoming traffic. */
+    port?: number;
+    /** Protocol is the highest network protocol we understand to load balance. Currently PROTOCOL_HTTP and PROTOCOL_HTTPS are supported. */
+    protocol?: ListenerProtocol | (string & {});
+    /** Enable Web Application Firewall (WAF), referenced by name. See "Application Load Balancer - Web Application Firewall API" for more information. */
+    wafConfigName?: string;
+}
+export declare const Listener: S.Schema<Listener>;
+/** There is a maximum listener count of 20. */
+export type CreateLoadBalancerRequestListenersList = Array<Listener>;
+export declare const CreateLoadBalancerRequestListenersList: S.Schema<CreateLoadBalancerRequestListenersList>;
+/** The role defines how the Application 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 declare const NetworkRole: any;
+export interface Network {
+    /** STACKIT network ID the Application Load Balancer and/or targets are in. */
+    networkId?: string;
+    /** The role defines how the Application Load Balancer is using the network. Currently only ROLE_LISTENERS_AND_TARGETS is supported. */
+    role?: NetworkRole | (string & {});
+}
+export declare const Network: 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 declare const CreateLoadBalancerRequestNetworksList: S.Schema<CreateLoadBalancerRequestNetworksList>;
+/** Application Load Balancer is accessible only from an IP address in this range. May be combined with `ipBlockListName`; `allowedSourceRanges` is evaluated first, then `ipBlockListName`. */
+export type LoadbalancerOptionAccessControlAllowedSourceRangesList = Array<string>;
+export declare const LoadbalancerOptionAccessControlAllowedSourceRangesList: S.Schema<LoadbalancerOptionAccessControlAllowedSourceRangesList>;
+/** Use this option to limit the IP ranges that can use the Application Load Balancer. `allowed_source_ranges` and `ip_block_list_name` may be set together. When both are set, `allowed_source_ranges` is evaluated first, then `ip_block_list_name` is evaluated. */
+export interface LoadbalancerOptionAccessControl {
+    /** Application Load Balancer is accessible only from an IP address in this range. May be combined with `ipBlockListName`; `allowedSourceRanges` is evaluated first, then `ipBlockListName`. */
+    allowedSourceRanges?: LoadbalancerOptionAccessControlAllowedSourceRangesList;
+    /** Reference to an IP block list by name. Traffic originating from any IP in the referenced list is denied access to the Application Load Balancer. See "IP Lists API" for how to manage IP block lists. May be combined with `allowedSourceRanges`; `allowedSourceRanges` is evaluated first, then `ipBlockListName`. */
+    ipBlockListName?: string;
+}
+export declare const LoadbalancerOptionAccessControl: S.Schema<LoadbalancerOptionAccessControl>;
+/** Observability logs configuration. */
+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 Application Load Balancer. */
+    credentialsRef?: string;
+    /** The Observability(Logs)/Loki remote write Push URL you want the logs to be shipped to. */
+    pushUrl?: string;
+}
+export declare const LoadbalancerOptionLogs: S.Schema<LoadbalancerOptionLogs>;
+/** Observability metrics configuration. */
+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 Application Load Balancer. */
+    credentialsRef?: string;
+    /** The Observability(Metrics)/Prometheus remote write push URL you want the metrics to be shipped to. */
+    pushUrl?: string;
+}
+export declare const LoadbalancerOptionMetrics: S.Schema<LoadbalancerOptionMetrics>;
+/** We offer Load Balancer observability via STACKIT Observability or external solutions. */
+export interface LoadbalancerOptionObservability {
+    logs?: LoadbalancerOptionLogs;
+    metrics?: LoadbalancerOptionMetrics;
+}
+export declare const LoadbalancerOptionObservability: S.Schema<LoadbalancerOptionObservability>;
+/** Defines any optional functionality you want to have enabled on your Application Load Balancer. */
+export interface LoadBalancerOptions {
+    accessControl?: LoadbalancerOptionAccessControl;
+    /** This option automates the handling of the external IP address for an Application Load Balancer. If set to true a new IP address will be automatically created. It will also be automatically deleted when the Load Balancer is deleted. */
+    ephemeralAddress?: boolean;
+    observability?: LoadbalancerOptionObservability;
+    /** Application Load Balancer is accessible only via a private network ip address. Not changeable after creation. */
+    privateNetworkOnly?: boolean;
+}
+export declare const LoadBalancerOptions: S.Schema<LoadBalancerOptions>;
+/** List of HTTP status codes that indicate a healthy response */
+export type HttpHealthChecksOkStatusesList = Array<string>;
+export declare const HttpHealthChecksOkStatusesList: 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 declare const TlsConfig: 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 declare const HttpHealthChecks: S.Schema<HttpHealthChecks>;
+/** Set this to customize active health checks for targets in this pool. */
+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 declare const ActiveHealthCheck: S.Schema<ActiveHealthCheck>;
+export interface Target {
+    /** Target display name. */
+    displayName?: string;
+    /** Private target IP, which must by unique within a target pool. */
+    ip?: string;
+}
+export declare const Target: S.Schema<Target>;
+/** List of all targets which will be used in the pool. Limited to 250. */
+export type TargetPoolTargetsList = Array<Target>;
+export declare const TargetPoolTargetsList: S.Schema<TargetPoolTargetsList>;
+export interface TargetPool {
+    activeHealthCheck?: ActiveHealthCheck;
+    /** Target pool name */
+    name?: string;
+    /** 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;
+    tlsConfig?: TlsConfig;
+}
+export declare const TargetPool: S.Schema<TargetPool>;
+/** List of all target pools which will be used in the Application Load Balancer. Limited to 20. */
+export type CreateLoadBalancerRequestTargetPoolsList = Array<TargetPool>;
+export declare const CreateLoadBalancerRequestTargetPoolsList: 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;
+    /** The external IP address where this Application 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 ALB. **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. */
+    listeners?: CreateLoadBalancerRequestListenersList;
+    /** Application 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 Application Load Balancer. Currently supported plan is p10. 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 Application Load Balancer. Limited to 20. */
+    targetPools?: CreateLoadBalancerRequestTargetPoolsList;
+}
+export declare const CreateLoadBalancerRequest: S.Schema<CreateLoadBalancerRequest>;
+/** The error type specifies which part of the Application 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 Application Load Balancer with try to use the provided IP and if not available reports TYPE_FIP_NOT_CONFIGURED error. */
+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 declare const LoadBalancerErrorType: any;
+export interface LoadBalancerError {
+    /** The error description contains additional helpful user information to fix the error state of the Application 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. */
+    description?: string;
+    /** The error type specifies which part of the Application 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 Application Load Balancer with try to use the provided IP and if not available reports TYPE_FIP_NOT_CONFIGURED error. */
+    type?: LoadBalancerErrorType;
+}
+export declare const LoadBalancerError: S.Schema<LoadBalancerError>;
+/** Reports all errors a Application Load Balancer has. */
+export type LoadBalancerErrorsList = Array<LoadBalancerError>;
+export declare const LoadBalancerErrorsList: S.Schema<LoadBalancerErrorsList>;
+/** Labels represent user-defined metadata as key-value pairs. Label count should not exceed 64 per ALB. **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 declare const LoadBalancerLabelsMap: S.Schema<LoadBalancerLabelsMap>;
+/** There is a maximum listener count of 20. */
+export type LoadBalancerListenersList = Array<Listener>;
+export declare const LoadBalancerListenersList: S.Schema<LoadBalancerListenersList>;
+export interface SecurityGroup {
+    /** ID of the security Group */
+    id?: string;
+    /** Name of the security Group */
+    name?: string;
+}
+export declare const SecurityGroup: 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 declare const LoadBalancerNetworksList: S.Schema<LoadBalancerNetworksList>;
+export type LoadBalancerStatus = "STATUS_UNSPECIFIED" | "STATUS_PENDING" | "STATUS_READY" | "STATUS_ERROR" | "STATUS_TERMINATING";
+export declare const LoadBalancerStatus: any;
+/** List of all target pools which will be used in the Application Load Balancer. Limited to 20. */
+export type LoadBalancerTargetPoolsList = Array<TargetPool>;
+export declare const LoadBalancerTargetPoolsList: S.Schema<LoadBalancerTargetPoolsList>;
+export interface LoadBalancer {
+    /** 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 Application Load Balancer has. */
+    errors?: LoadBalancerErrorsList;
+    /** The external IP address where this Application 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 ALB. **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. */
+    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;
+    /** Application 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 Application Load Balancer. Currently supported plan is p10. 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 Application 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 Application 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;
+    /** Application Load Balancer resource version. Must be empty or unset for creating Application Load Balancers, non-empty for updating. Semantics: While retrieving, this is the current version of this Application Load Balancer resource that changes during updates. On updates this field specified the Application 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 Application 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 Application 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 declare const LoadBalancer: S.Schema<LoadBalancer>;
+export interface DeleteCredentialsRequest {
+    projectId: string;
+    region: string;
+    credentialsRef: string;
+}
+export declare const DeleteCredentialsRequest: S.Schema<DeleteCredentialsRequest>;
+export type DeleteCredentialsResponse2 = unknown;
+export declare const DeleteCredentialsResponse2: S.Schema<DeleteCredentialsResponse2>;
+export interface DeleteLoadBalancerRequest {
+    projectId: string;
+    region: string;
+    name: string;
+}
+export declare const DeleteLoadBalancerRequest: S.Schema<DeleteLoadBalancerRequest>;
+export type DeleteLoadBalancerResponse2 = unknown;
+export declare const DeleteLoadBalancerResponse2: S.Schema<DeleteLoadBalancerResponse2>;
+export interface GetCredentialsRequest {
+    projectId: string;
+    region: string;
+    credentialsRef: string;
+}
+export declare const GetCredentialsRequest: S.Schema<GetCredentialsRequest>;
+export interface GetCredentialsResponse {
+    credential?: CredentialsResponse;
+}
+export declare const GetCredentialsResponse: S.Schema<GetCredentialsResponse>;
+export interface GetLoadBalancerRequest {
+    projectId: string;
+    region: string;
+    name: string;
+}
+export declare const GetLoadBalancerRequest: S.Schema<GetLoadBalancerRequest>;
+export interface GetQuotaRequest {
+    projectId: string;
+    region: string;
+}
+export declare const GetQuotaRequest: 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 declare const GetQuotaResponse: S.Schema<GetQuotaResponse>;
+export interface ListCredentialsRequest {
+    projectId: string;
+    region: string;
+}
+export declare const ListCredentialsRequest: S.Schema<ListCredentialsRequest>;
+export type ListCredentialsResponseCredentialsList = Array<CredentialsResponse>;
+export declare const ListCredentialsResponseCredentialsList: S.Schema<ListCredentialsResponseCredentialsList>;
+export interface ListCredentialsResponse {
+    credentials?: ListCredentialsResponseCredentialsList;
+}
+export declare const ListCredentialsResponse: S.Schema<ListCredentialsResponse>;
+export interface ListLoadBalancersRequest {
+    projectId: string;
+    region: string;
+    /** page_size specifies how many Application 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 declare const ListLoadBalancersRequest: S.Schema<ListLoadBalancersRequest>;
+export type ListLoadBalancersResponseLoadBalancersList = Array<LoadBalancer>;
+export declare const ListLoadBalancersResponseLoadBalancersList: S.Schema<ListLoadBalancersResponseLoadBalancersList>;
+export interface ListLoadBalancersResponse {
+    loadBalancers?: ListLoadBalancersResponseLoadBalancersList;
+    /** Continue token from the ListLoadBalancerResponse with Limit option */
+    nextPageId?: string;
+}
+export declare const ListLoadBalancersResponse: S.Schema<ListLoadBalancersResponse>;
+export interface ListPlansRequest {
+    region: string;
+}
+export declare const ListPlansRequest: S.Schema<ListPlansRequest>;
+export interface PlanDetails {
+    /** Description */
+    description?: string;
+    /** Flavor Name */
+    flavorName?: string;
+    /** Maximum number of concurrent connections per Application 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 declare const PlanDetails: S.Schema<PlanDetails>;
+/** List of available service plans. */
+export type ListPlansResponseValidPlansList = Array<PlanDetails>;
+export declare const ListPlansResponseValidPlansList: S.Schema<ListPlansResponseValidPlansList>;
+export interface ListPlansResponse {
+    /** List of available service plans. */
+    validPlans?: ListPlansResponseValidPlansList;
+}
+export declare const ListPlansResponse: 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 declare const UpdateCredentialsRequest: S.Schema<UpdateCredentialsRequest>;
+export interface UpdateCredentialsResponse {
+    credential?: CredentialsResponse;
+}
+export declare const UpdateCredentialsResponse: S.Schema<UpdateCredentialsResponse>;
+/** Labels represent user-defined metadata as key-value pairs. Label count should not exceed 64 per ALB. **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 declare const UpdateLoadBalancerRequestLabelsMap: S.Schema<UpdateLoadBalancerRequestLabelsMap>;
+/** There is a maximum listener count of 20. */
+export type UpdateLoadBalancerRequestListenersList = Array<Listener>;
+export declare const UpdateLoadBalancerRequestListenersList: 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 declare const UpdateLoadBalancerRequestNetworksList: S.Schema<UpdateLoadBalancerRequestNetworksList>;
+/** List of all target pools which will be used in the Application Load Balancer. Limited to 20. */
+export type UpdateLoadBalancerRequestTargetPoolsList = Array<TargetPool>;
+export declare const UpdateLoadBalancerRequestTargetPoolsList: 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;
+    /** The external IP address where this Application 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 ALB. **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. */
+    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 Application Load Balancer. Currently supported plan is p10. 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 Application Load Balancer. Limited to 20. */
+    targetPools?: UpdateLoadBalancerRequestTargetPoolsList;
+    /** Application Load Balancer resource version. Must be empty or unset for creating Application Load Balancers, non-empty for updating. Semantics: While retrieving, this is the current version of this Application Load Balancer resource that changes during updates. On updates this field specified the Application 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 Application 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 Application 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 declare const UpdateLoadBalancerRequest: S.Schema<UpdateLoadBalancerRequest>;
+/** List of all targets which will be used in the pool. Limited to 250. */
+export type UpdateTargetPoolRequestTargetsList = Array<Target>;
+export declare const UpdateTargetPoolRequestTargetsList: S.Schema<UpdateTargetPoolRequestTargetsList>;
+export interface UpdateTargetPoolRequest {
+    projectId: string;
+    region: string;
+    name: string;
+    targetPoolName: string;
+    activeHealthCheck?: ActiveHealthCheck;
+    /** 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;
+    tlsConfig?: TlsConfig;
+}
+export declare const UpdateTargetPoolRequest: S.Schema<UpdateTargetPoolRequest>;
+export type CreateCredentialsError = BadRequest | Forbidden | StackitOpError;
+/** Create credentials for observability of the Application 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 declare const createCredentials: API.OperationMethod<CreateCredentialsRequest, CreateCredentialsResponse, CreateCredentialsError, StackitOpContext>;
+export type CreateLoadBalancerError = BadRequest | Forbidden | Conflict | StackitOpError;
+/** Create an Application Load Balancer in a project Creates an Application Load Balancer. The default load balancing algorithm is Maglev, and selecting a different algorithm is currently not supported. */
+export declare const createLoadBalancer: API.OperationMethod<CreateLoadBalancerRequest, LoadBalancer, CreateLoadBalancerError, StackitOpContext>;
+export type DeleteCredentialsError = BadRequest | Forbidden | StackitOpError;
+/** Delete a single credential in a project. Deletes the stored Observability credentials. */
+export declare const deleteCredentials: API.OperationMethod<DeleteCredentialsRequest, DeleteCredentialsResponse2, DeleteCredentialsError, StackitOpContext>;
+export type DeleteLoadBalancerError = BadRequest | Forbidden | StackitOpError;
+/** Delete a given load balancer in a project. Deletes the specified Application Load Balancer. */
+export declare const deleteLoadBalancer: API.OperationMethod<DeleteLoadBalancerRequest, DeleteLoadBalancerResponse2, DeleteLoadBalancerError, StackitOpContext>;
+export type GetCredentialsError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get a single credential reference in a project. Gets the stored Observability credentials. */
+export declare const getCredentials: API.OperationMethod<GetCredentialsRequest, GetCredentialsResponse, GetCredentialsError, StackitOpContext>;
+export type GetLoadBalancerError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get a single Application Load Balancer in a project. Retrieves details of a specific Application Load Balancer in a project. Includes creation and update information, current status, and any error descriptions. */
+export declare const getLoadBalancer: API.OperationMethod<GetLoadBalancerRequest, LoadBalancer, GetLoadBalancerError, StackitOpContext>;
+export type GetQuotaError = BadRequest | Forbidden | StackitOpError;
+/** Get the quota of Application Load Balancers in a project. Retrieves the configured Application Load Balancer quota for the project. Limit can be changed via service request. */
+export declare const getQuota: API.OperationMethod<GetQuotaRequest, GetQuotaResponse, GetQuotaError, StackitOpContext>;
+export type ListCredentialsError = BadRequest | Forbidden | StackitOpError;
+/** List all credentials in a project. Lists the stored Observability credentials. */
+export declare const listCredentials: API.OperationMethod<ListCredentialsRequest, ListCredentialsResponse, ListCredentialsError, StackitOpContext>;
+export type ListLoadBalancersError = BadRequest | Forbidden | StackitOpError;
+/** List Application Load Balancers in a project. Lists all Application Load Balancers in a project. Includes details from creation or updates, along with their status and any error descriptions. */
+export declare const listLoadBalancers: API.OperationMethod<ListLoadBalancersRequest, ListLoadBalancersResponse, ListLoadBalancersError, StackitOpContext>;
+export type ListPlansError = BadRequest | Forbidden | StackitOpError;
+/** List available service plans. Lists the configured service plans for a project. */
+export declare const listPlans: API.OperationMethod<ListPlansRequest, ListPlansResponse, ListPlansError, StackitOpContext>;
+export type UpdateCredentialsError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Update credentials for observability in a project. Updates the stored Observability credentials. */
+export declare const updateCredentials: API.OperationMethod<UpdateCredentialsRequest, UpdateCredentialsResponse, UpdateCredentialsError, StackitOpContext>;
+export type UpdateLoadBalancerError = BadRequest | Forbidden | Conflict | StackitOpError;
+/** Update a load balancer in a project. Updates an existing Application Load Balancer by modifying its listeners and target pools. Ensure the resource version is current to maintain concurrency safety. The default load balancing algorithm is Maglev, and selecting a different algorithm is currently not supported. */
+export declare const updateLoadBalancer: API.OperationMethod<UpdateLoadBalancerRequest, LoadBalancer, UpdateLoadBalancerError, StackitOpContext>;
+export type UpdateTargetPoolError = BadRequest | Forbidden | StackitOpError;
+/** Update a single target pool of a load balancer in a project. Replaces the content of a specific target pool in the Application Load Balancer (useful for adding or removing target servers). Only updates the specified target pool, leaving others unchanged. Cannot be used to create or rename target pools. */
+export declare const updateTargetPool: API.OperationMethod<UpdateTargetPoolRequest, TargetPool, UpdateTargetPoolError, StackitOpContext>;
+//# sourceMappingURL=alb.d.ts.map