@distilled.cloud/stackit 1.0.0-rc.15 → 1.0.0-rc.17

package/lib/services/cdn.d.ts

@@ -1,32 +1,32 @@
 import * as API from "@distilled.cloud/core/api";
-import * as S from "@distilled.cloud/core/schema";
-import * as Redacted from "effect/Redacted";
+import * as S from "@distilled.cloud/core/schema-lite";
+import type * as Redacted from "effect/Redacted";
 import { type StackitOpError, type StackitOpContext } from "../protocol.ts";
 export type { StackitOpError, StackitOpContext };
-declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+declare const BadRequest_base: S.TaggedErrorClass<"BadRequest", {
     readonly code: any;
     readonly message: any;
-}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+}> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         BadRequestError: true;
     };
 });
 export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
 }
-declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+declare const NotFound_base: S.TaggedErrorClass<"NotFound", {
     readonly code: any;
     readonly message: any;
-}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+}> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         BadRequestError: true;
     };
 });
 export declare class NotFound extends /*@__PURE__*/ NotFound_base {
 }
-declare const UnprocessableEntity_base: S.Class<UnprocessableEntity, S.TaggedStruct<"UnprocessableEntity", {
+declare const UnprocessableEntity_base: S.TaggedErrorClass<"UnprocessableEntity", {
     readonly code: any;
     readonly message: any;
-}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+}> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         BadRequestError: true;
     };
@@ -34,20 +34,16 @@ declare const UnprocessableEntity_base: S.Class<UnprocessableEntity, S.TaggedStr
 export declare class UnprocessableEntity extends /*@__PURE__*/ UnprocessableEntity_base {
 }
 export type HttpBackendCreateGeofencingValueList = Array<string>;
-export declare const HttpBackendCreateGeofencingValueList: S.Schema<HttpBackendCreateGeofencingValueList>;
 /** An object mapping multiple alternative origins to country codes. Any request from one of those country codes will route to the alternative origin. Do note that country codes may only be used once. You cannot have a country be assigned to multiple alternative origins. */
 export type HttpBackendCreateGeofencingMap = {
     [key: string]: HttpBackendCreateGeofencingValueList | undefined;
 };
-export declare const HttpBackendCreateGeofencingMap: S.Schema<HttpBackendCreateGeofencingMap>;
 /** Headers that will be sent with every request to the configured origin. **WARNING**: Do not store sensitive values in the headers. The configuration is stored as plain text. */
 export type HttpBackendCreateOriginRequestHeadersMap = {
     [key: string]: string | undefined;
 };
-export declare const HttpBackendCreateOriginRequestHeadersMap: S.Schema<HttpBackendCreateOriginRequestHeadersMap>;
 /** Defines the type of content origin. For this schema, it must be set to `http`. */
 export type HttpBackendCreateType = "http";
-export declare const HttpBackendCreateType: any;
 export interface HttpBackendCreate {
     /** An object mapping multiple alternative origins to country codes. Any request from one of those country codes will route to the alternative origin. Do note that country codes may only be used once. You cannot have a country be assigned to multiple alternative origins. */
     geofencing?: HttpBackendCreateGeofencingMap;
@@ -58,15 +54,12 @@ export interface HttpBackendCreate {
     /** Defines the type of content origin. For this schema, it must be set to `http`. */
     type: HttpBackendCreateType;
 }
-export declare const HttpBackendCreate: S.Schema<HttpBackendCreate>;
 export interface BucketCredentials {
     accessKeyId: string | Redacted.Redacted<string>;
     secretAccessKey: string | Redacted.Redacted<string>;
 }
-export declare const BucketCredentials: S.Schema<BucketCredentials>;
 /** Defines the type of content origin. For this schema, it must be set to `bucket`. */
 export type BucketBackendCreateType = "bucket";
-export declare const BucketBackendCreateType: any;
 export interface BucketBackendCreate {
     /** The fully qualified URL of your cloud storage bucket (for example, `https://s3.eu-central-1.amazonaws.com/my-bucket`). */
     bucketUrl: string;
@@ -76,22 +69,16 @@ export interface BucketBackendCreate {
     /** Defines the type of content origin. For this schema, it must be set to `bucket`. */
     type: BucketBackendCreateType;
 }
-export declare const BucketBackendCreate: S.Schema<BucketBackendCreate>;
 /** Configuration for the content origin backend. */
 export type CreateDistributionRequestBackend = HttpBackendCreate | BucketBackendCreate;
-export declare const CreateDistributionRequestBackend: S.Schema<CreateDistributionRequestBackend>;
 /** Restricts access to your content based on country. We use the ISO 3166-1 alpha-2 standard for country codes (e.g., DE, ES, GB). This setting blocks users from the specified countries. */
 export type CreateDistributionRequestBlockedCountriesList = Array<string>;
-export declare const CreateDistributionRequestBlockedCountriesList: S.Schema<CreateDistributionRequestBlockedCountriesList>;
 /** Restricts access to your content by specifying a list of blocked IPv4 addresses. This feature enhances security and privacy by preventing these addresses from accessing your distribution. */
 export type CreateDistributionRequestBlockedIpsList = Array<string>;
-export declare const CreateDistributionRequestBlockedIpsList: S.Schema<CreateDistributionRequestBlockedIpsList>;
 /** HTTP request header names whose values participate in the cache key. Each entry multiplies the number of cache variants by the number of distinct values observed for that header. */
 export type CacheConfigCreateCacheKeyHeadersList = Array<string>;
-export declare const CacheConfigCreateCacheKeyHeadersList: S.Schema<CacheConfigCreateCacheKeyHeadersList>;
 /** Allowlist of query-string parameter names that participate in the cache key when `queryStringVaryEnabled` is true. Ignored while `queryStringVaryEnabled` is false, but still stored so it can be re-activated without losing the list. */
 export type CacheConfigCreateQueryStringVaryParametersList = Array<string>;
-export declare const CacheConfigCreateQueryStringVaryParametersList: S.Schema<CacheConfigCreateQueryStringVaryParametersList>;
 /** Groups the cache options that influence how the CDN builds its cache key on distribution creation. **Cache cardinality warning:** enabling query-string vary produces one cache entry per unique query-string combination (**unbounded** when `queryStringVaryParameters` is empty). Each entry in `cacheKeyHeaders` multiplies the number of cache variants by the number of distinct values observed for that header. Use these settings sparingly. `queryStringVaryParameters` is stored independently of `queryStringVaryEnabled` so that this feature can be toggled on and off without losing the configured allowlist. Only `queryStringVaryEnabled` gates whether the parameter allowlist actually varies the cache. **Optimizer interaction:** when the Optimizer is enabled, the CDN automatically enables query-string vary for image responses regardless of this setting. */
 export interface CacheConfigCreate {
     /** HTTP request header names whose values participate in the cache key. Each entry multiplies the number of cache variants by the number of distinct values observed for that header. */
@@ -101,12 +88,10 @@ export interface CacheConfigCreate {
     /** Allowlist of query-string parameter names that participate in the cache key when `queryStringVaryEnabled` is true. Ignored while `queryStringVaryEnabled` is false, but still stored so it can be re-activated without losing the list. */
     queryStringVaryParameters?: CacheConfigCreateQueryStringVaryParametersList;
 }
-export declare const CacheConfigCreate: S.Schema<CacheConfigCreate>;
 /** Labels are key-value string pairs that can be attached to a distribution. */
 export type CreateDistributionRequestLabelsMap = {
     [key: string]: string | undefined;
 };
-export declare const CreateDistributionRequestLabelsMap: S.Schema<CreateDistributionRequestLabelsMap>;
 /** The authentication credentials required for the CDN to push logs to your Loki instance. */
 export interface LokiLogSinkCredentials {
     /** The password corresponding to your username. */
@@ -114,10 +99,8 @@ export interface LokiLogSinkCredentials {
     /** The username used to authenticate against your Loki instance. */
     username: string;
 }
-export declare const LokiLogSinkCredentials: S.Schema<LokiLogSinkCredentials>;
 /** Defines the type of the log sink. For Grafana Loki, this must be set to `loki`. */
 export type LokiLogSinkCreateType = "loki";
-export declare const LokiLogSinkCreateType: any;
 export interface LokiLogSinkCreate {
     credentials: LokiLogSinkCredentials;
     /** The fully qualified URL where the CDN should push logs to your Loki instance (for example, `https://loki.example.com/loki/api/v1/push`). */
@@ -125,10 +108,8 @@ export interface LokiLogSinkCreate {
     /** Defines the type of the log sink. For Grafana Loki, this must be set to `loki`. */
     type: LokiLogSinkCreateType;
 }
-export declare const LokiLogSinkCreate: S.Schema<LokiLogSinkCreate>;
 /** Defines bearer token authentication. */
 export type OtlpLogSinkBearerCredentialsType = "bearer";
-export declare const OtlpLogSinkBearerCredentialsType: any;
 /** Bearer token authentication credentials for OTLP. */
 export interface OtlpLogSinkBearerCredentials {
     /** The bearer token used to authenticate against your OTLP endpoint. */
@@ -136,10 +117,8 @@ export interface OtlpLogSinkBearerCredentials {
     /** Defines bearer token authentication. */
     type: OtlpLogSinkBearerCredentialsType;
 }
-export declare const OtlpLogSinkBearerCredentials: S.Schema<OtlpLogSinkBearerCredentials>;
 /** Defines basic authentication. */
 export type OtlpLogSinkBasicCredentialsType = "basic";
-export declare const OtlpLogSinkBasicCredentialsType: any;
 /** Basic authentication credentials for OTLP. */
 export interface OtlpLogSinkBasicCredentials {
     /** The password corresponding to your username. */
@@ -149,13 +128,10 @@ export interface OtlpLogSinkBasicCredentials {
     /** The username used to authenticate against your OTLP endpoint. */
     username: string;
 }
-export declare const OtlpLogSinkBasicCredentials: S.Schema<OtlpLogSinkBasicCredentials>;
 /** The authentication credentials required for the CDN to push logs to your OTLP endpoint. */
 export type OtlpLogSinkCreateCredentials = OtlpLogSinkBearerCredentials | OtlpLogSinkBasicCredentials;
-export declare const OtlpLogSinkCreateCredentials: S.Schema<OtlpLogSinkCreateCredentials>;
 /** Defines the type of the log sink. */
 export type OtlpLogSinkCreateType = "otlp";
-export declare const OtlpLogSinkCreateType: any;
 export interface OtlpLogSinkCreate {
     /** The authentication credentials required for the CDN to push logs to your OTLP endpoint. */
     credentials: OtlpLogSinkCreateCredentials;
@@ -164,34 +140,26 @@ export interface OtlpLogSinkCreate {
     /** Defines the type of the log sink. */
     type: OtlpLogSinkCreateType;
 }
-export declare const OtlpLogSinkCreate: S.Schema<OtlpLogSinkCreate>;
 export type CreateDistributionRequestLogSink = LokiLogSinkCreate | OtlpLogSinkCreate;
-export declare const CreateDistributionRequestLogSink: S.Schema<CreateDistributionRequestLogSink>;
 /** Optimizer is paid feature, a real-time on the fly image manipulation and optimization service that automatically optimizes your images for faster image delivery. */
 export interface Optimizer {
     /** Determines if the optimizer should be enabled for this distribution and incurs a monthly fee */
     enabled: boolean;
 }
-export declare const Optimizer: S.Schema<Optimizer>;
 /** Defines how multiple matchers within this rule are combined (ALL, ANY, NONE). Defaults to ANY. */
 export type MatchCondition = "ANY" | "ALL" | "NONE";
-export declare const MatchCondition: any;
 /** A list of glob patterns to match against the request path. At least one value is required. Examples: "/shop/*" or "*\/img/*" */
 export type MatcherValuesList = Array<string>;
-export declare const MatcherValuesList: S.Schema<MatcherValuesList>;
 /** A matcher containing a list of string values to compare against the request path. */
 export interface Matcher {
     valueMatchCondition?: MatchCondition | (string & {});
     /** A list of glob patterns to match against the request path. At least one value is required. Examples: "/shop/*" or "*\/img/*" */
     values: MatcherValuesList;
 }
-export declare const Matcher: S.Schema<Matcher>;
 /** A list of matchers that define when this rule should apply. At least one matcher is required. */
 export type RedirectRuleMatchersList = Array<Matcher>;
-export declare const RedirectRuleMatchersList: S.Schema<RedirectRuleMatchersList>;
 /** The HTTP status code for the redirect. Must be one of 301, 302, 303, 307, or 308. */
 export type RedirectRuleStatusCode = 301 | 302 | 303 | 307 | 308;
-export declare const RedirectRuleStatusCode: any;
 /** A single redirect rule defining a source pattern and a target URL. */
 export interface RedirectRule {
     /** An optional description for the redirect rule. */
@@ -206,22 +174,17 @@ export interface RedirectRule {
     /** The target URL to redirect to. Must be a valid URI. */
     targetUrl: string;
 }
-export declare const RedirectRule: S.Schema<RedirectRule>;
 /** A list of redirect rules. The order of rules matters for evaluation. */
 export type RedirectConfigRulesList = Array<RedirectRule>;
-export declare const RedirectConfigRulesList: S.Schema<RedirectConfigRulesList>;
 /** A wrapper for a list of redirect rules that allows for redirect settings on a distribution. */
 export interface RedirectConfig {
     /** A list of redirect rules. The order of rules matters for evaluation. */
     rules?: RedirectConfigRulesList;
 }
-export declare const RedirectConfig: S.Schema<RedirectConfig>;
 /** The following regions exist: - `EU` - Europe - `US` - United States / North America - `AF` - Africa - `SA` - South America - `ASIA` - Asia and Oceania */
 export type Region = "EU" | "US" | "AF" | "SA" | "ASIA";
-export declare const Region: any;
 /** Define in which regions you would like your content to be cached. */
 export type CreateDistributionRequestRegionsList = Array<Region | (string & {})>;
-export declare const CreateDistributionRequestRegionsList: S.Schema<CreateDistributionRequestRegionsList>;
 /** Configuration for TLS protocol versions. Note: Enabling older TLS versions (1.0, 1.1) is generally discouraged for security reasons. */
 export interface TlsConfig {
     /** If set to true, the distribution will accept connections using TLS 1.0. */
@@ -229,51 +192,35 @@ export interface TlsConfig {
     /** If set to true, the distribution will accept connections using TLS 1.1. */
     enableTls11: boolean;
 }
-export declare const TlsConfig: S.Schema<TlsConfig>;
 /** This whitelist restricts which HTTP methods the distribution accepts. Requests using non-whitelisted methods are blocked by the WAF before reaching the origin. Common methods: `GET`, `POST`, `PUT`, `DELETE`, `PATCH`, `HEAD`, `OPTIONS`, `CONNECT`, `TRACE` Validation ensures: 1. At least one method is allowed 2. No duplicate methods (e.g., `GET` appearing twice) 3. Each method is valid per HTTP standards */
 export type WafConfigAllowedHttpMethodsList = Array<string>;
-export declare const WafConfigAllowedHttpMethodsList: S.Schema<WafConfigAllowedHttpMethodsList>;
 export type WafConfigAllowedHttpVersionsList = Array<string>;
-export declare const WafConfigAllowedHttpVersionsList: S.Schema<WafConfigAllowedHttpVersionsList>;
 /** This allow list restricts which Content-Type headers are accepted in request bodies. Format: Must be `type/subtype` with no spaces. Common content types: - `application/json` - `application/x-www-form-urlencoded` - `multipart/form-data` - `text/html` - `text/plain` - `application/xml` */
 export type WafConfigAllowedRequestContentTypesList = Array<string>;
-export declare const WafConfigAllowedRequestContentTypesList: S.Schema<WafConfigAllowedRequestContentTypesList>;
 /** Ids of WAF Collections to mark as disabled */
 export type WafConfigDisabledRuleCollectionIdsList = Array<string>;
-export declare const WafConfigDisabledRuleCollectionIdsList: S.Schema<WafConfigDisabledRuleCollectionIdsList>;
 /** Ids of WAF Rule Groups to mark as disabled */
 export type WafConfigDisabledRuleGroupIdsList = Array<string>;
-export declare const WafConfigDisabledRuleGroupIdsList: S.Schema<WafConfigDisabledRuleGroupIdsList>;
 /** Ids of WAF Rules that are **explicitly** disabled for this distribution. */
 export type WafConfigDisabledRuleIdsList = Array<string>;
-export declare const WafConfigDisabledRuleIdsList: S.Schema<WafConfigDisabledRuleIdsList>;
 /** Ids of WAF Collections to mark as enabled */
 export type WafConfigEnabledRuleCollectionIdsList = Array<string>;
-export declare const WafConfigEnabledRuleCollectionIdsList: S.Schema<WafConfigEnabledRuleCollectionIdsList>;
 /** Ids of WAF Rule Groups to mark as enabled */
 export type WafConfigEnabledRuleGroupIdsList = Array<string>;
-export declare const WafConfigEnabledRuleGroupIdsList: S.Schema<WafConfigEnabledRuleGroupIdsList>;
 /** Ids of the WAF rules that are **explicitly** enabled for this distribution. If this rule is in a disabled / log Only RuleGroup or Collection, it will be enabled regardless as `enabledRuleIds` overrides those in specificity. Do note that rules can also be enabled because a Rulegroup or Collection is enabled. **DO NOT** use this property to find all active rules. Instead, pass `?withWafStatus=true` as a query parameter to `GetDistribution` or `ListDistributions`. This will expose the `waf` Property on distribution Level. From there you can `$.waf.enabledRules.map(e => e.id)` to get a list of all enabled rules. */
 export type WafConfigEnabledRuleIdsList = Array<string>;
-export declare const WafConfigEnabledRuleIdsList: S.Schema<WafConfigEnabledRuleIdsList>;
 /** Ids of WAF Collections to mark as log Only. */
 export type WafConfigLogOnlyRuleCollectionIdsList = Array<string>;
-export declare const WafConfigLogOnlyRuleCollectionIdsList: S.Schema<WafConfigLogOnlyRuleCollectionIdsList>;
 /** Ids of WAF Rule Groups to mark as log Only. */
 export type WafConfigLogOnlyRuleGroupIdsList = Array<string>;
-export declare const WafConfigLogOnlyRuleGroupIdsList: S.Schema<WafConfigLogOnlyRuleGroupIdsList>;
 /** Ids of WAF Rules that are **explicitly** marked as Log Only for this distribution. */
 export type WafConfigLogOnlyRuleIdsList = Array<string>;
-export declare const WafConfigLogOnlyRuleIdsList: S.Schema<WafConfigLogOnlyRuleIdsList>;
 /** - `ENABLED`: The WAF actively inspects and blocks malicious requests. - `DISABLED`: The WAF is completely off. No inspection occurs. - `LOG_ONLY`: The WAF inspects requests and logs matches but never blocks. */
 export type WafMode = "DISABLED" | "ENABLED" | "LOG_ONLY";
-export declare const WafMode: any;
 /** The paranoia level defines how aggressively the WAF should action on requests. It ranges from `L1` (least strict, lowest chance of false positives) to `L4` (most strict, highest chance of false positives). A higher paranoia level is more effective at catching attacks but can also block legitimate traffic. */
 export type WafParanoiaLevel = "L1" | "L2" | "L3" | "L4";
-export declare const WafParanoiaLevel: any;
 /** Enable or disable the Premium WAF. Do note that enabling the Premium WAF will cause additional fees. Some features are gated behind the Premium WAF, like additional, **premium-only rules** and the ability to create **custom rules** (not yet implemented) */
 export type WafType = "FREE" | "PREMIUM";
-export declare const WafType: any;
 /** Configuration of the WAF of a distribution A WAF Config always contains a WAF Mode and Type. If a WAF was never enabled, most of the properties are not present. To **enable** the WAF for your Distribution, you must set the `mode` to `ENABLED` or `LOG_ONLY`. This causes the other properties to be populated. ## Rules There are 9 properties used to control which Rules are enabled, disabled or set to Log-Only. These properties can be grouped in 3 groups of 3. Each of these groups varies in specificity: Rules are more specific than Rule Groups, which in turn are more specific than Collections. More specific definitions override more generic definitions. ### Collections - `enabledRuleCollectionIds` - `disabledRuleCollectionIds` - `logOnlyRuleCollectionIds` These are the least specific selectors. As of 2025, only two collections exist: - `@builtin/crs/response`, containing all Rules regarding Responses - `@builtin/crs/request`, containing all Rules regarding Requests More collections may be added in the future ### Rule Groups - `enabledRuleGroupIds` - `disabledRuleGroupIds` - `logOnlyRuleGroupIds` These are more specific than Collections and will override their selector. You can find all available Rule Groups by calling the `ListWafCollections` Operation. ### Rules - `enabledRuleIds` - `disabledRuleIds` - `logOnlyRuleGds` Being the most specific selectors, these will override both Collection and Rule Group selectors. You can find all available Rule Groups by calling the `ListWafCollections` Operation. ### TIP: Review resolved config If you call `GetDistribution` with `?withWafStatus=true`, you get back a resolved WAF Rules Config which contains a `waf` property which you can inspect to see why a Rule is either enabled, disabled or logOnly. */
 export interface WafConfig {
     /** This whitelist restricts which HTTP methods the distribution accepts. Requests using non-whitelisted methods are blocked by the WAF before reaching the origin. Common methods: `GET`, `POST`, `PUT`, `DELETE`, `PATCH`, `HEAD`, `OPTIONS`, `CONNECT`, `TRACE` Validation ensures: 1. At least one method is allowed 2. No duplicate methods (e.g., `GET` appearing twice) 3. Each method is valid per HTTP standards */
@@ -303,7 +250,6 @@ export interface WafConfig {
     paranoiaLevel?: WafParanoiaLevel | (string & {});
     type: WafType | (string & {});
 }
-export declare const WafConfig: S.Schema<WafConfig>;
 export interface CreateDistributionRequest {
     /** Your STACKIT Project Id */
     projectId: string;
@@ -334,22 +280,17 @@ export interface CreateDistributionRequest {
     tls?: TlsConfig;
     waf?: WafConfig;
 }
-export declare const CreateDistributionRequest: S.Schema<CreateDistributionRequest>;
 export type HttpBackendGeofencingValueList = Array<string>;
-export declare const HttpBackendGeofencingValueList: S.Schema<HttpBackendGeofencingValueList>;
 /** An object mapping multiple alternative origins to country codes. Any request from one of those country codes will route to the alternative origin. Do note that country codes may only be used once. You cannot have a country be assigned to multiple alternative origins. */
 export type HttpBackendGeofencingMap = {
     [key: string]: HttpBackendGeofencingValueList | undefined;
 };
-export declare const HttpBackendGeofencingMap: S.Schema<HttpBackendGeofencingMap>;
 /** Headers that will be sent with every request to the configured origin. **WARNING**: Do not store sensitive values in the headers. The configuration is stored as plain text. */
 export type HttpBackendOriginRequestHeadersMap = {
     [key: string]: string | undefined;
 };
-export declare const HttpBackendOriginRequestHeadersMap: S.Schema<HttpBackendOriginRequestHeadersMap>;
 /** Defines the type of content origin. For this schema, it must be set to `http`. */
 export type HttpBackendType = "http";
-export declare const HttpBackendType: any;
 export interface HttpBackend {
     /** An object mapping multiple alternative origins to country codes. Any request from one of those country codes will route to the alternative origin. Do note that country codes may only be used once. You cannot have a country be assigned to multiple alternative origins. */
     geofencing: HttpBackendGeofencingMap;
@@ -360,10 +301,8 @@ export interface HttpBackend {
     /** Defines the type of content origin. For this schema, it must be set to `http`. */
     type: HttpBackendType;
 }
-export declare const HttpBackend: S.Schema<HttpBackend>;
 /** Defines the type of content origin. For this schema, it must be set to `bucket`. */
 export type BucketBackendType = "bucket";
-export declare const BucketBackendType: any;
 export interface BucketBackend {
     /** The fully qualified URL of your cloud storage bucket (for example, `https://s3.eu-central-1.amazonaws.com/my-bucket`). */
     bucketUrl: string;
@@ -372,21 +311,15 @@ export interface BucketBackend {
     /** Defines the type of content origin. For this schema, it must be set to `bucket`. */
     type: BucketBackendType;
 }
-export declare const BucketBackend: S.Schema<BucketBackend>;
 export type ConfigBackend = HttpBackend | BucketBackend;
-export declare const ConfigBackend: S.Schema<ConfigBackend>;
 /** Restricts access to your content based on country. We use the ISO 3166-1 alpha-2 standard for country codes (e.g. DE, ES, GB). This setting blocks users from the specified countries. */
 export type ConfigBlockedCountriesList = Array<string>;
-export declare const ConfigBlockedCountriesList: S.Schema<ConfigBlockedCountriesList>;
 /** Restricts access to your content by specifying a list of blocked IPv4 addresses. This feature enhances security and privacy by preventing these addresses from accessing your distribution. */
 export type ConfigBlockedIpsList = Array<string>;
-export declare const ConfigBlockedIpsList: S.Schema<ConfigBlockedIpsList>;
 /** HTTP request header names whose values participate in the cache key. Each entry multiplies the number of cache variants by the number of distinct values observed for that header. */
 export type CacheConfigCacheKeyHeadersList = Array<string>;
-export declare const CacheConfigCacheKeyHeadersList: S.Schema<CacheConfigCacheKeyHeadersList>;
 /** Allowlist of query-string parameter names that participate in the cache key when `queryStringVaryEnabled` is true. Ignored while `queryStringVaryEnabled` is false, but still stored so it can be re-activated without losing the list. */
 export type CacheConfigQueryStringVaryParametersList = Array<string>;
-export declare const CacheConfigQueryStringVaryParametersList: S.Schema<CacheConfigQueryStringVaryParametersList>;
 /** Groups the cache options that influence how the CDN builds its cache key. **Cache cardinality warning:** enabling query-string vary produces one cache entry per unique query-string combination (**unbounded** when `queryStringVaryParameters` is empty). Each entry in `cacheKeyHeaders` multiplies the number of cache variants by the number of distinct values observed for that header. Use these settings sparingly. `queryStringVaryParameters` is stored independently of `queryStringVaryEnabled` so that this feature can be toggled on and off without losing the configured allowlist. Only `queryStringVaryEnabled` gates whether the parameter allowlist actually varies the cache. **Optimizer interaction:** when the Optimizer is enabled, the CDN automatically enables query-string vary for image responses regardless of this setting. */
 export interface CacheConfig {
     /** HTTP request header names whose values participate in the cache key. Each entry multiplies the number of cache variants by the number of distinct values observed for that header. */
@@ -396,36 +329,28 @@ export interface CacheConfig {
     /** Allowlist of query-string parameter names that participate in the cache key when `queryStringVaryEnabled` is true. Ignored while `queryStringVaryEnabled` is false, but still stored so it can be re-activated without losing the list. */
     queryStringVaryParameters: CacheConfigQueryStringVaryParametersList;
 }
-export declare const CacheConfig: S.Schema<CacheConfig>;
 /** Labels are key-value string pairs that can be attached to a distribution. */
 export type ConfigLabelsMap = {
     [key: string]: string | undefined;
 };
-export declare const ConfigLabelsMap: S.Schema<ConfigLabelsMap>;
 /** Defines the type of the log sink. */
 export type LokiLogSinkType = "loki";
-export declare const LokiLogSinkType: any;
 export interface LokiLogSink {
     /** The fully qualified URL where the CDN should push logs to your Loki instance (for example, `https://loki.example.com/loki/api/v1/push`). */
     pushUrl: string;
     /** Defines the type of the log sink. */
     type: LokiLogSinkType;
 }
-export declare const LokiLogSink: S.Schema<LokiLogSink>;
 /** Defines the type of the log sink. */
 export type OtlpLogSinkType = "otlp";
-export declare const OtlpLogSinkType: any;
 export interface OtlpLogSink {
     /** The fully qualified URL where the CDN should push logs to your OTLP endpoint (for example, `https://otlp.example.com/otlp/v1/logs`). */
     pushUrl: string;
     /** Defines the type of the log sink. */
     type: OtlpLogSinkType;
 }
-export declare const OtlpLogSink: S.Schema<OtlpLogSink>;
 export type ConfigLogSink = LokiLogSink | OtlpLogSink;
-export declare const ConfigLogSink: S.Schema<ConfigLogSink>;
 export type ConfigRegionsList = Array<Region>;
-export declare const ConfigRegionsList: S.Schema<ConfigRegionsList>;
 export interface Config {
     backend: ConfigBackend;
     /** Restricts access to your content based on country. We use the ISO 3166-1 alpha-2 standard for country codes (e.g. DE, ES, GB). This setting blocks users from the specified countries. */
@@ -450,12 +375,9 @@ export interface Config {
     tls: TlsConfig;
     waf: WafConfig;
 }
-export declare const Config: S.Schema<Config>;
 export type DomainCertificateType = "managed" | "custom";
-export declare const DomainCertificateType: any;
 /** An enum value that describes a Status Error. */
 export type StatusErrorKey = "UNKNOWN" | "CUSTOM_DOMAIN_CNAME_MISSING" | "CUSTOM_DOMAIN_ALREADY_IN_USE" | "PUBLIC_BETA_QUOTA_REACHED" | "LOG_SINK_INSTANCE_UNAVAILABLE" | "EXTERNAL_QUOTA_REACHED";
-export declare const StatusErrorKey: any;
 export interface StatusError {
     /** A german translation string corresponding to the error key. Note that we do not guarantee german translations are present. */
     de?: string;
@@ -464,16 +386,12 @@ export interface StatusError {
     /** An enum value that describes a Status Error. */
     key: StatusErrorKey;
 }
-export declare const StatusError: S.Schema<StatusError>;
 /** This object is present if the custom domain has errors. */
 export type DomainErrorsList = Array<StatusError>;
-export declare const DomainErrorsList: S.Schema<DomainErrorsList>;
 /** The status of the domain: CREATING indicates that the custom domain is being set up. UPDATING means that requested changes are being applied to the custom domain. ACTIVE means the custom domain is currently configured and active. DELETING means that the domain is in the process of being removed from the distribution. In case the domain has the ERROR state, more information will be available in the errors list. */
 export type DomainStatus = "CREATING" | "ACTIVE" | "UPDATING" | "DELETING" | "ERROR";
-export declare const DomainStatus: any;
 /** Specifies the type of this Domain. Custom Domain can be further queries using the GetCustomDomain Endpoint */
 export type DomainType = "managed" | "custom";
-export declare const DomainType: any;
 /** Definition of a custom or managed domain without any certificates or keys */
 export interface Domain {
     certificateType: DomainCertificateType;
@@ -485,72 +403,56 @@ export interface Domain {
     /** Specifies the type of this Domain. Custom Domain can be further queries using the GetCustomDomain Endpoint */
     type: DomainType;
 }
-export declare const Domain: S.Schema<Domain>;
 export type DistributionDomainsList = Array<Domain>;
-export declare const DistributionDomainsList: S.Schema<DistributionDomainsList>;
 /** This object may be present if, and only if the distribution has encountered an error state. */
 export type DistributionErrorsList = Array<StatusError>;
-export declare const DistributionErrorsList: S.Schema<DistributionErrorsList>;
 /** - `CREATING`: The distribution was just created. All the relevant resources are created in the background. Once fully reconciled, this switches to `ACTIVE`. If there are any issues, the status changes to `ERROR`. You can look at the `errors` array to get more infos. - `ACTIVE`: The usual state. The desired configuration is synced, there are no errors - `UPDATING`: The state when there is a discrepancy between the desired and actual configuration state. This occurs right after an update. Will switch to `ACTIVE` or `ERROR`, depending on if synchronizing succeeds or not. - `DELETING`: The state right after a delete request was received. The distribution will stay in this status until all resources have been successfully removed, or until we encounter an `ERROR` state. **NOTE:** You can keep fetching the distribution while it is deleting. After successful deletion, trying to get a distribution will return a 404 Not Found response - `ERROR`: The error state. Look at the `errors` array for more info. */
 export type DistributionStatus = "CREATING" | "ACTIVE" | "UPDATING" | "DELETING" | "ERROR";
-export declare const DistributionStatus: any;
 /** This object only ever shows up in the disabled rules section. If rules are never defined (e.g. no collection, rule group, or the rule itself is ever mentioned), they are implicitly disabled */
 export interface WafStatusRuleBlockReasonNeverDefined {
     /** This is always `neverDefined` */
     type: string;
 }
-export declare const WafStatusRuleBlockReasonNeverDefined: S.Schema<WafStatusRuleBlockReasonNeverDefined>;
 export interface WafStatusRuleBlockReasonDirectlyDefined {
     /** This is always `directlyDefined` */
     type: string;
 }
-export declare const WafStatusRuleBlockReasonDirectlyDefined: S.Schema<WafStatusRuleBlockReasonDirectlyDefined>;
 /** A list containing all WAF Types which can use this Rule. You must patch you WAF to one of these WAF Types to make use of this rule. Rules show up with this state if they would have been enabled or logOnly otherwise. */
 export type WafStatusRuleBlockReasonInvalidWafTypeAllowedWafTypesList = Array<WafType>;
-export declare const WafStatusRuleBlockReasonInvalidWafTypeAllowedWafTypesList: S.Schema<WafStatusRuleBlockReasonInvalidWafTypeAllowedWafTypesList>;
 export interface WafStatusRuleBlockReasonInvalidWafType {
     /** A list containing all WAF Types which can use this Rule. You must patch you WAF to one of these WAF Types to make use of this rule. Rules show up with this state if they would have been enabled or logOnly otherwise. */
     allowedWafTypes: WafStatusRuleBlockReasonInvalidWafTypeAllowedWafTypesList;
     /** This is always `invalidWafType` */
     type: string;
 }
-export declare const WafStatusRuleBlockReasonInvalidWafType: S.Schema<WafStatusRuleBlockReasonInvalidWafType>;
 export interface WafStatusRuleBlockReasonInheritedFromCollection {
     /** The Collection that caused this rule to be in its current state. */
     collectionId: string;
     /** This is always `inheritedFromCollection` */
     type: string;
 }
-export declare const WafStatusRuleBlockReasonInheritedFromCollection: S.Schema<WafStatusRuleBlockReasonInheritedFromCollection>;
 export interface WafStatusRuleBlockReasonInheritedFromGroup {
     /** The Group that caused this rule to be in its current state. */
     groupId: string;
     /** This is always `inheritedFromGroup` */
     type: string;
 }
-export declare const WafStatusRuleBlockReasonInheritedFromGroup: S.Schema<WafStatusRuleBlockReasonInheritedFromGroup>;
 /** Defines the Reason why a Rule is in the specified state (set to be enabled, disabled or logOnly). */
 export type WafStatusRuleBlockReason = WafStatusRuleBlockReasonNeverDefined | WafStatusRuleBlockReasonDirectlyDefined | WafStatusRuleBlockReasonInvalidWafType | WafStatusRuleBlockReasonInheritedFromCollection | WafStatusRuleBlockReasonInheritedFromGroup;
-export declare const WafStatusRuleBlockReason: S.Schema<WafStatusRuleBlockReason>;
 export interface WafStatusRuleBlock {
     /** Specifies the Id of the Rule. */
     id: string;
     reason: WafStatusRuleBlockReason;
 }
-export declare const WafStatusRuleBlock: S.Schema<WafStatusRuleBlock>;
 export type DistributionWafDisabledRulesList = Array<WafStatusRuleBlock>;
-export declare const DistributionWafDisabledRulesList: S.Schema<DistributionWafDisabledRulesList>;
 export type DistributionWafEnabledRulesList = Array<WafStatusRuleBlock>;
-export declare const DistributionWafEnabledRulesList: S.Schema<DistributionWafEnabledRulesList>;
 export type DistributionWafLogOnlyRulesList = Array<WafStatusRuleBlock>;
-export declare const DistributionWafLogOnlyRulesList: S.Schema<DistributionWafLogOnlyRulesList>;
 /** For this property to be present two pre-conditions must be met: - the WAF was enabled at least once - the query parameter ?withWafStatus is truthy This property contains the waf Status. At this point in time, this contains all resolved rules. Rules are split into 3 groups: - enabledRules - logOnlyRules - disabledRules **Do note that the global waf mode (Disabled, LogOnly, Enabled) is *NOT* reflected in this list!** */
 export interface DistributionWaf {
     disabledRules: DistributionWafDisabledRulesList;
     enabledRules: DistributionWafEnabledRulesList;
     logOnlyRules: DistributionWafLogOnlyRulesList;
 }
-export declare const DistributionWaf: S.Schema<DistributionWaf>;
 export interface Distribution {
     config: Config;
     /** RFC3339 string defining when the distribution was created */
@@ -567,11 +469,9 @@ export interface Distribution {
     /** For this property to be present two pre-conditions must be met: - the WAF was enabled at least once - the query parameter ?withWafStatus is truthy This property contains the waf Status. At this point in time, this contains all resolved rules. Rules are split into 3 groups: - enabledRules - logOnlyRules - disabledRules **Do note that the global waf mode (Disabled, LogOnly, Enabled) is *NOT* reflected in this list!** */
     waf?: DistributionWaf;
 }
-export declare const Distribution: S.Schema<Distribution>;
 export interface CreateDistributionResponse {
     distribution: Distribution;
 }
-export declare const CreateDistributionResponse: S.Schema<CreateDistributionResponse>;
 export interface DeleteCustomDomainRequest {
     /** Your STACKIT Project Id */
     projectId: string;
@@ -579,10 +479,8 @@ export interface DeleteCustomDomainRequest {
     domain: string;
     intentId?: string;
 }
-export declare const DeleteCustomDomainRequest: S.Schema<DeleteCustomDomainRequest>;
 /** This object is present if the custom domain has errors. */
 export type CustomDomainErrorsList = Array<StatusError>;
-export declare const CustomDomainErrorsList: S.Schema<CustomDomainErrorsList>;
 /** Definition of a custom domain */
 export interface CustomDomain {
     /** This object is present if the custom domain has errors. */
@@ -591,12 +489,10 @@ export interface CustomDomain {
     name: string;
     status: DomainStatus;
 }
-export declare const CustomDomain: S.Schema<CustomDomain>;
 /** Returns the custom domain that was deleted while the deletion has not completed yet. After the deletion was successful the response will be empty. */
 export interface DeleteCustomDomainResponse {
     customDomain?: CustomDomain;
 }
-export declare const DeleteCustomDomainResponse: S.Schema<DeleteCustomDomainResponse>;
 export interface DeleteDistributionRequest {
     /** Your STACKIT Project Id */
     projectId: string;
@@ -604,11 +500,9 @@ export interface DeleteDistributionRequest {
     /** While optional, it is greatly encouraged to provide an `intentId`. This is used to deduplicate requests. If multiple DELETE-Requests with the same `intentId` are received, all but the first request are dropped. */
     intentId?: string;
 }
-export declare const DeleteDistributionRequest: S.Schema<DeleteDistributionRequest>;
 export interface DeleteDistributionResponse {
     distribution?: Distribution;
 }
-export declare const DeleteDistributionResponse: S.Schema<DeleteDistributionResponse>;
 export interface FindCachePathsRequest {
     /** Your STACKIT Project Id */
     projectId: string;
@@ -616,52 +510,41 @@ export interface FindCachePathsRequest {
     /** A substring of the search query. */
     path: string;
 }
-export declare const FindCachePathsRequest: S.Schema<FindCachePathsRequest>;
 export interface FindCachePathsResponseEntry {
     /** Defines one path that was previously used as part of a granular purge */
     path: string;
 }
-export declare const FindCachePathsResponseEntry: S.Schema<FindCachePathsResponseEntry>;
 export type FindCachePathsResponseResponseList = Array<FindCachePathsResponseEntry>;
-export declare const FindCachePathsResponseResponseList: S.Schema<FindCachePathsResponseResponseList>;
 export interface FindCachePathsResponse {
     response: FindCachePathsResponseResponseList;
 }
-export declare const FindCachePathsResponse: S.Schema<FindCachePathsResponse>;
 export interface GetCacheInfoRequest {
     /** Your STACKIT Project Id */
     projectId: string;
     distributionId: string;
     purgePath?: string;
 }
-export declare const GetCacheInfoRequest: S.Schema<GetCacheInfoRequest>;
 export type GetCacheInfoResponseHistoryEntryType = "full" | "granular";
-export declare const GetCacheInfoResponseHistoryEntryType: any;
 export interface GetCacheInfoResponseHistoryEntry {
     occurredAt: string;
     type: GetCacheInfoResponseHistoryEntryType;
 }
-export declare const GetCacheInfoResponseHistoryEntry: S.Schema<GetCacheInfoResponseHistoryEntry>;
 export type GetCacheInfoResponseHistoryList = Array<GetCacheInfoResponseHistoryEntry>;
-export declare const GetCacheInfoResponseHistoryList: S.Schema<GetCacheInfoResponseHistoryList>;
 export interface GetCacheInfoResponse {
     history: GetCacheInfoResponseHistoryList;
     /** Returns the last time the cache was purged by calling the PurgeCache endpoint. Time represented as RFC3339 compliant string. If the cache was never purged, this returns `null` */
     lastPurgeTime: string | null;
 }
-export declare const GetCacheInfoResponse: S.Schema<GetCacheInfoResponse>;
 export interface GetCustomDomainRequest {
     /** Your STACKIT Project Id */
     projectId: string;
     distributionId: string;
     domain: string;
 }
-export declare const GetCustomDomainRequest: S.Schema<GetCustomDomainRequest>;
 /** This is returned when no custom certificate is used. We provision and manage a Let's Encrypt Certificate for you */
 export interface GetCustomDomainManagedCertificate {
     type: string;
 }
-export declare const GetCustomDomainManagedCertificate: S.Schema<GetCustomDomainManagedCertificate>;
 /** Returned if a custom certificate is used. Response does not contain the certificate or key. */
 export interface GetCustomDomainCustomCertificate {
     /** Returns if the CNAME Check has been disabled for this Custom Domain. This is usually set for migrations to allow for no downtime. */
@@ -670,14 +553,11 @@ export interface GetCustomDomainCustomCertificate {
     /** Whenever a new custom certificate is added the version is increased by 1. */
     version: number;
 }
-export declare const GetCustomDomainCustomCertificate: S.Schema<GetCustomDomainCustomCertificate>;
 export type GetCustomDomainResponseCertificate = GetCustomDomainManagedCertificate | GetCustomDomainCustomCertificate;
-export declare const GetCustomDomainResponseCertificate: S.Schema<GetCustomDomainResponseCertificate>;
 export interface GetCustomDomainResponse {
     certificate: GetCustomDomainResponseCertificate;
     customDomain: CustomDomain;
 }
-export declare const GetCustomDomainResponse: S.Schema<GetCustomDomainResponse>;
 export interface GetDistributionRequest {
     /** Your STACKIT Project Id */
     projectId: string;
@@ -685,18 +565,13 @@ export interface GetDistributionRequest {
     /** If set, the top level of a distribution contains a `waf` property, which defines the status of the waf. This includes a list of all resolved rules. */
     withWafStatus?: boolean;
 }
-export declare const GetDistributionRequest: S.Schema<GetDistributionRequest>;
 export interface GetDistributionResponse {
     distribution: Distribution;
 }
-export declare const GetDistributionResponse: S.Schema<GetDistributionResponse>;
 export type GetLogsRequestSortBy = "timestamp" | "dataCenterRegion" | "requestCountryCode" | "statusCode" | "cacheHit" | "size" | "path" | "host";
-export declare const GetLogsRequestSortBy: any;
 export type GetLogsRequestSortOrder = "ascending" | "descending";
-export declare const GetLogsRequestSortOrder: any;
 /** The action a WAF rule can take based on a request */
 export type WAFRuleAction = "BLOCKED" | "LOGGED" | "ALLOWED";
-export declare const WAFRuleAction: any;
 export interface GetLogsRequest {
     /** Your STACKIT Project Id */
     projectId: string;
@@ -724,11 +599,9 @@ export interface GetLogsRequest {
     /** Filters based on whether the request was served from the CDN cache. Can be combined with other filters */
     cacheHit?: boolean;
 }
-export declare const GetLogsRequest: S.Schema<GetLogsRequest>;
 export type WAFViolationRequestHeadersMap = {
     [key: string]: string | undefined;
 };
-export declare const WAFViolationRequestHeadersMap: S.Schema<WAFViolationRequestHeadersMap>;
 /** Information about a violated WAF rule in case the WAF is enabled and a rule was triggered (either in BLOCK or LOG_ONLY mode) */
 export interface WAFViolation {
     action: WAFRuleAction;
@@ -742,7 +615,6 @@ export interface WAFViolation {
     /** ID of the WAF rule that was triggered */
     ruleId: string;
 }
-export declare const WAFViolation: S.Schema<WAFViolation>;
 export interface DistributionLogsRecord {
     cacheHit: boolean;
     dataCenterRegion: string;
@@ -756,14 +628,11 @@ export interface DistributionLogsRecord {
     timestamp: string;
     wafViolation?: WAFViolation;
 }
-export declare const DistributionLogsRecord: S.Schema<DistributionLogsRecord>;
 export type GetLogsResponseLogsList = Array<DistributionLogsRecord>;
-export declare const GetLogsResponseLogsList: S.Schema<GetLogsResponseLogsList>;
 export interface GetLogsResponse {
     logs: GetLogsResponseLogsList;
     nextPageIdentifier?: string;
 }
-export declare const GetLogsResponse: S.Schema<GetLogsResponse>;
 export interface GetLogsSearchFiltersRequest {
     /** Your STACKIT Project ID. */
     projectId: string;
@@ -772,27 +641,18 @@ export interface GetLogsSearchFiltersRequest {
     /** Optional search string. Will search the **values** for the text input. */
     filter?: string;
 }
-export declare const GetLogsSearchFiltersRequest: S.Schema<GetLogsSearchFiltersRequest>;
 export type GetLogsSearchFiltersResponseCacheItem = "HIT" | "MISS";
-export declare const GetLogsSearchFiltersResponseCacheItem: any;
 export type GetLogsSearchFiltersResponseCacheList = Array<GetLogsSearchFiltersResponseCacheItem>;
-export declare const GetLogsSearchFiltersResponseCacheList: S.Schema<GetLogsSearchFiltersResponseCacheList>;
 /** A datacenter. The `id` defines the key needed to filter against the logs endpoint, while the `displayName` defines a human-readable Name. */
 export interface GetLogsSearchFiltersResponseDatacenterBlockItem {
     displayName: string;
     id: string;
 }
-export declare const GetLogsSearchFiltersResponseDatacenterBlockItem: S.Schema<GetLogsSearchFiltersResponseDatacenterBlockItem>;
 export type GetLogsSearchFiltersResponseDatacenterBlockAFList = Array<GetLogsSearchFiltersResponseDatacenterBlockItem>;
-export declare const GetLogsSearchFiltersResponseDatacenterBlockAFList: S.Schema<GetLogsSearchFiltersResponseDatacenterBlockAFList>;
 export type GetLogsSearchFiltersResponseDatacenterBlockASIAList = Array<GetLogsSearchFiltersResponseDatacenterBlockItem>;
-export declare const GetLogsSearchFiltersResponseDatacenterBlockASIAList: S.Schema<GetLogsSearchFiltersResponseDatacenterBlockASIAList>;
 export type GetLogsSearchFiltersResponseDatacenterBlockEUList = Array<GetLogsSearchFiltersResponseDatacenterBlockItem>;
-export declare const GetLogsSearchFiltersResponseDatacenterBlockEUList: S.Schema<GetLogsSearchFiltersResponseDatacenterBlockEUList>;
 export type GetLogsSearchFiltersResponseDatacenterBlockNAList = Array<GetLogsSearchFiltersResponseDatacenterBlockItem>;
-export declare const GetLogsSearchFiltersResponseDatacenterBlockNAList: S.Schema<GetLogsSearchFiltersResponseDatacenterBlockNAList>;
 export type GetLogsSearchFiltersResponseDatacenterBlockSAList = Array<GetLogsSearchFiltersResponseDatacenterBlockItem>;
-export declare const GetLogsSearchFiltersResponseDatacenterBlockSAList: S.Schema<GetLogsSearchFiltersResponseDatacenterBlockSAList>;
 /** Object containing Datacenters to filter for. Each datacenter is grouped to the respective region. */
 export interface GetLogsSearchFiltersResponseDatacenterBlock {
     AF: GetLogsSearchFiltersResponseDatacenterBlockAFList;
@@ -801,13 +661,10 @@ export interface GetLogsSearchFiltersResponseDatacenterBlock {
     NA: GetLogsSearchFiltersResponseDatacenterBlockNAList;
     SA: GetLogsSearchFiltersResponseDatacenterBlockSAList;
 }
-export declare const GetLogsSearchFiltersResponseDatacenterBlock: S.Schema<GetLogsSearchFiltersResponseDatacenterBlock>;
 /** List of ISO-3166 Alpha2 Country Codes matching the input filter. Response is ordered in ascending order. For more Info about the country codes, see https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2 */
 export type GetLogsSearchFiltersResponseRemoteCountryList = Array<string>;
-export declare const GetLogsSearchFiltersResponseRemoteCountryList: S.Schema<GetLogsSearchFiltersResponseRemoteCountryList>;
 /** List of Status Codes matching the input filter. Response is ordered in ascending order. */
 export type GetLogsSearchFiltersResponseStatusList = Array<number>;
-export declare const GetLogsSearchFiltersResponseStatusList: S.Schema<GetLogsSearchFiltersResponseStatusList>;
 export interface GetLogsSearchFiltersResponse {
     cache: GetLogsSearchFiltersResponseCacheList;
     dataCenter: GetLogsSearchFiltersResponseDatacenterBlock;
@@ -816,9 +673,7 @@ export interface GetLogsSearchFiltersResponse {
     /** List of Status Codes matching the input filter. Response is ordered in ascending order. */
     status: GetLogsSearchFiltersResponseStatusList;
 }
-export declare const GetLogsSearchFiltersResponse: S.Schema<GetLogsSearchFiltersResponse>;
 export type GetStatisticsRequestInterval = "hourly" | "daily" | "monthly" | "yearly";
-export declare const GetStatisticsRequestInterval: any;
 export interface GetStatisticsRequest {
     /** Your STACKIT Project Id */
     projectId: string;
@@ -830,7 +685,6 @@ export interface GetStatisticsRequest {
     /** Over which interval should statistics be aggregated? defaults to hourly resolution **NOTE**: Intervals are grouped in buckets that start and end based on a day in UTC+0 time. So for the `daily` interval, the group starts (inclusive) and ends (exclusive) at `00:00Z` */
     interval?: GetStatisticsRequestInterval | (string & {});
 }
-export declare const GetStatisticsRequest: S.Schema<GetStatisticsRequest>;
 export interface DistributionStatisticsRecordEntry {
     /** Number of cached requests that were served */
     cachedRequests: number;
@@ -839,7 +693,6 @@ export interface DistributionStatisticsRecordEntry {
     /** Total traffic in bytes that occurred during the time interval */
     totalTrafficBytes: number;
 }
-export declare const DistributionStatisticsRecordEntry: S.Schema<DistributionStatisticsRecordEntry>;
 /** Mapping of regions to the metrics for this region for the defined time interval All regions are always present. If no traffic was reported for a region, it will still contain 0-filled properties */
 export interface DistributionStatisticsRecordRegions {
     AF: DistributionStatisticsRecordEntry;
@@ -848,7 +701,6 @@ export interface DistributionStatisticsRecordRegions {
     SA: DistributionStatisticsRecordEntry;
     US: DistributionStatisticsRecordEntry;
 }
-export declare const DistributionStatisticsRecordRegions: S.Schema<DistributionStatisticsRecordRegions>;
 /** Aggregated statistics of a distribution during a time interval */
 export interface DistributionStatisticsRecord {
     /** Number of cached requests that were served */
@@ -863,17 +715,12 @@ export interface DistributionStatisticsRecord {
     /** Start of the time interval the statistics refer to */
     start: string;
 }
-export declare const DistributionStatisticsRecord: S.Schema<DistributionStatisticsRecord>;
 export type GetStatisticsResponseRecordsList = Array<DistributionStatisticsRecord>;
-export declare const GetStatisticsResponseRecordsList: S.Schema<GetStatisticsResponseRecordsList>;
 export interface GetStatisticsResponse {
     records: GetStatisticsResponseRecordsList;
 }
-export declare const GetStatisticsResponse: S.Schema<GetStatisticsResponse>;
 export type ListDistributionsRequestSortBy = "id" | "updatedAt" | "createdAt" | "originUrl" | "status" | "originUrlRelated";
-export declare const ListDistributionsRequestSortBy: any;
 export type ListDistributionsRequestSortOrder = "ascending" | "descending";
-export declare const ListDistributionsRequestSortOrder: any;
 export interface ListDistributionsRequest {
     /** Your STACKIT Project Id */
     projectId: string;
@@ -887,68 +734,52 @@ export interface ListDistributionsRequest {
     sortBy?: ListDistributionsRequestSortBy | (string & {});
     sortOrder?: ListDistributionsRequestSortOrder | (string & {});
 }
-export declare const ListDistributionsRequest: S.Schema<ListDistributionsRequest>;
 export type ListDistributionsResponseDistributionsList = Array<Distribution>;
-export declare const ListDistributionsResponseDistributionsList: S.Schema<ListDistributionsResponseDistributionsList>;
 export interface ListDistributionsResponse {
     distributions: ListDistributionsResponseDistributionsList;
     nextPageIdentifier?: string;
 }
-export declare const ListDistributionsResponse: S.Schema<ListDistributionsResponse>;
 export interface ListWafCollectionsRequest {
     /** Your STACKIT Project Id */
     projectId: string;
 }
-export declare const ListWafCollectionsRequest: S.Schema<ListWafCollectionsRequest>;
 /** LocalizedString is a map from language to string value */
 export type LocalizedString = {
     [key: string]: string | undefined;
 };
-export declare const LocalizedString: S.Schema<LocalizedString>;
 export interface WafRule {
     /** Optional CoreRuleSet rule Id in case this is a CRS rule */
     code?: string;
     description: LocalizedString;
     id: string;
 }
-export declare const WafRule: S.Schema<WafRule>;
 export type WafRuleGroupRulesList = Array<WafRule>;
-export declare const WafRuleGroupRulesList: S.Schema<WafRuleGroupRulesList>;
 export interface WafRuleGroup {
     description: LocalizedString;
     name: LocalizedString;
     rules: WafRuleGroupRulesList;
 }
-export declare const WafRuleGroup: S.Schema<WafRuleGroup>;
 export type WafRuleCollectionGroupsList = Array<WafRuleGroup>;
-export declare const WafRuleCollectionGroupsList: S.Schema<WafRuleCollectionGroupsList>;
 export interface WafRuleCollection {
     groups: WafRuleCollectionGroupsList;
     id: string;
     name: LocalizedString;
 }
-export declare const WafRuleCollection: S.Schema<WafRuleCollection>;
 export type ListWafCollectionsResponseCollectionsList = Array<WafRuleCollection>;
-export declare const ListWafCollectionsResponseCollectionsList: S.Schema<ListWafCollectionsResponseCollectionsList>;
 export interface ListWafCollectionsResponse {
     collections: ListWafCollectionsResponseCollectionsList;
 }
-export declare const ListWafCollectionsResponse: S.Schema<ListWafCollectionsResponse>;
 export type HttpBackendPatchGeofencingValueList = Array<string>;
-export declare const HttpBackendPatchGeofencingValueList: S.Schema<HttpBackendPatchGeofencingValueList>;
 /** An object mapping multiple alternative origins to country codes. Any request from one of those country codes will route to the alternative origin. Do note that country codes may only be used once. You cannot have a country be assigned to multiple alternative origins. */
 export type HttpBackendPatchGeofencingMap = {
     [key: string]: HttpBackendPatchGeofencingValueList | undefined;
 };
-export declare const HttpBackendPatchGeofencingMap: S.Schema<HttpBackendPatchGeofencingMap>;
 /** Headers that will be sent with every request to the configured origin. **WARNING**: Do not store sensitive values in the headers. The configuration is stored as plain text. */
 export type HttpBackendPatchOriginRequestHeadersMap = {
     [key: string]: string | undefined;
 };
-export declare const HttpBackendPatchOriginRequestHeadersMap: S.Schema<HttpBackendPatchOriginRequestHeadersMap>;
 /** Defines the type of content origin. For this schema, it must be set to `http`. */
 export type HttpBackendPatchType = "http";
-export declare const HttpBackendPatchType: any;
 /** A partial HTTP Backend */
 export interface HttpBackendPatch {
     /** An object mapping multiple alternative origins to country codes. Any request from one of those country codes will route to the alternative origin. Do note that country codes may only be used once. You cannot have a country be assigned to multiple alternative origins. */
@@ -960,10 +791,8 @@ export interface HttpBackendPatch {
     /** Defines the type of content origin. For this schema, it must be set to `http`. */
     type: HttpBackendPatchType;
 }
-export declare const HttpBackendPatch: S.Schema<HttpBackendPatch>;
 /** Defines the type of content origin. For this schema, it must be set to `bucket`. */
 export type BucketBackendPatchType = "bucket";
-export declare const BucketBackendPatchType: any;
 export interface BucketBackendPatch {
     /** The fully qualified URL of your cloud storage bucket (for example, `https://s3.eu-central-1.amazonaws.com/my-bucket`). */
     bucketUrl?: string;
@@ -973,21 +802,15 @@ export interface BucketBackendPatch {
     /** Defines the type of content origin. For this schema, it must be set to `bucket`. */
     type: BucketBackendPatchType;
 }
-export declare const BucketBackendPatch: S.Schema<BucketBackendPatch>;
 export type ConfigPatchBackend = HttpBackendPatch | BucketBackendPatch;
-export declare const ConfigPatchBackend: S.Schema<ConfigPatchBackend>;
 /** Restricts access to your content based on country. We use the ISO 3166-1 alpha-2 standard for country codes (e.g., DE, ES, GB). This setting blocks users from the specified countries. */
 export type ConfigPatchBlockedCountriesList = Array<string>;
-export declare const ConfigPatchBlockedCountriesList: S.Schema<ConfigPatchBlockedCountriesList>;
 /** Restricts access to your content by specifying a list of blocked IPv4 addresses. This feature enhances security and privacy by preventing these addresses from accessing your distribution. */
 export type ConfigPatchBlockedIpsList = Array<string>;
-export declare const ConfigPatchBlockedIpsList: S.Schema<ConfigPatchBlockedIpsList>;
 /** HTTP request header names that participate in the cache key. Omit to leave unchanged; send `[]` to clear. */
 export type CacheConfigPatchCacheKeyHeadersList = Array<string>;
-export declare const CacheConfigPatchCacheKeyHeadersList: S.Schema<CacheConfigPatchCacheKeyHeadersList>;
 /** Allowlist of query-string parameter names. Omit to leave unchanged; send `[]` to clear. */
 export type CacheConfigPatchQueryStringVaryParametersList = Array<string>;
-export declare const CacheConfigPatchQueryStringVaryParametersList: S.Schema<CacheConfigPatchQueryStringVaryParametersList>;
 /** PATCH variant of `CacheConfig`. Follows the standard PATCH conventions for this API: - Field omitted from the request: current value is left unchanged. - Array field sent as `[]`: current list is cleared. - `queryStringVaryEnabled` is a plain boolean (non-nullable); omit it to leave unchanged. `queryStringVaryParameters` is stored independently of `queryStringVaryEnabled`. Sending a non-empty `queryStringVaryParameters` together with `queryStringVaryEnabled=false` is accepted: the list is persisted for later re-activation but does not affect the cache while the flag is false. */
 export interface CacheConfigPatch {
     /** HTTP request header names that participate in the cache key. Omit to leave unchanged; send `[]` to clear. */
@@ -997,15 +820,12 @@ export interface CacheConfigPatch {
     /** Allowlist of query-string parameter names. Omit to leave unchanged; send `[]` to clear. */
     queryStringVaryParameters?: CacheConfigPatchQueryStringVaryParametersList;
 }
-export declare const CacheConfigPatch: S.Schema<CacheConfigPatch>;
 /** Labels are key-value string pairs that can be attached to a distribution. JSON Merge Patch is supported, meaning setting a key to null will remove it. */
 export type ConfigPatchLabelsMap = {
     [key: string]: string | null | undefined;
 };
-export declare const ConfigPatchLabelsMap: S.Schema<ConfigPatchLabelsMap>;
 /** Defines the type of the log sink. For Grafana Loki, this must be set to `loki`. */
 export type LokiLogSinkPatchType = "loki";
-export declare const LokiLogSinkPatchType: any;
 export interface LokiLogSinkPatch {
     credentials?: LokiLogSinkCredentials;
     /** The fully qualified URL where the CDN should push logs to your Loki instance (for example, `https://loki.example.com/loki/api/v1/push`). */
@@ -1013,13 +833,10 @@ export interface LokiLogSinkPatch {
     /** Defines the type of the log sink. For Grafana Loki, this must be set to `loki`. */
     type: LokiLogSinkPatchType;
 }
-export declare const LokiLogSinkPatch: S.Schema<LokiLogSinkPatch>;
 /** The authentication credentials required for the CDN to push logs to your OTLP endpoint. */
 export type OtlpLogSinkPatchCredentials = OtlpLogSinkBearerCredentials | OtlpLogSinkBasicCredentials;
-export declare const OtlpLogSinkPatchCredentials: S.Schema<OtlpLogSinkPatchCredentials>;
 /** Defines the type of the log sink. */
 export type OtlpLogSinkPatchType = "otlp";
-export declare const OtlpLogSinkPatchType: any;
 export interface OtlpLogSinkPatch {
     /** The authentication credentials required for the CDN to push logs to your OTLP endpoint. */
     credentials?: OtlpLogSinkPatchCredentials;
@@ -1028,15 +845,11 @@ export interface OtlpLogSinkPatch {
     /** Defines the type of the log sink. */
     type: OtlpLogSinkPatchType;
 }
-export declare const OtlpLogSinkPatch: S.Schema<OtlpLogSinkPatch>;
 export type ConfigPatchLogSink = LokiLogSinkPatch | OtlpLogSinkPatch;
-export declare const ConfigPatchLogSink: S.Schema<ConfigPatchLogSink>;
 export interface OptimizerPatch {
     enabled?: boolean;
 }
-export declare const OptimizerPatch: S.Schema<OptimizerPatch>;
 export type ConfigPatchRegionsList = Array<Region | (string & {})>;
-export declare const ConfigPatchRegionsList: S.Schema<ConfigPatchRegionsList>;
 /** Configuration for TLS protocol versions. Note: Enabling older TLS versions (1.0, 1.1) is generally discouraged for security reasons. */
 export interface TlsConfigPatch {
     /** If set to true, the distribution will accept connections using TLS 1.0. */
@@ -1044,40 +857,27 @@ export interface TlsConfigPatch {
     /** If set to true, the distribution will accept connections using TLS 1.1. */
     enableTls11?: boolean;
 }
-export declare const TlsConfigPatch: S.Schema<TlsConfigPatch>;
 export type WafConfigPatchAllowedHttpMethodsList = Array<string>;
-export declare const WafConfigPatchAllowedHttpMethodsList: S.Schema<WafConfigPatchAllowedHttpMethodsList>;
 export type WafConfigPatchAllowedHttpVersionsList = Array<string>;
-export declare const WafConfigPatchAllowedHttpVersionsList: S.Schema<WafConfigPatchAllowedHttpVersionsList>;
 export type WafConfigPatchAllowedRequestContentTypesList = Array<string>;
-export declare const WafConfigPatchAllowedRequestContentTypesList: S.Schema<WafConfigPatchAllowedRequestContentTypesList>;
 /** Ids of WAF Collections to mark as disabled */
 export type WafConfigPatchDisabledRuleCollectionIdsList = Array<string>;
-export declare const WafConfigPatchDisabledRuleCollectionIdsList: S.Schema<WafConfigPatchDisabledRuleCollectionIdsList>;
 /** Ids of WAF Rule Groups to mark as disabled */
 export type WafConfigPatchDisabledRuleGroupIdsList = Array<string>;
-export declare const WafConfigPatchDisabledRuleGroupIdsList: S.Schema<WafConfigPatchDisabledRuleGroupIdsList>;
 /** Ids of WAF Rules that are **explicitly** disabled for this distribution. */
 export type WafConfigPatchDisabledRuleIdsList = Array<string>;
-export declare const WafConfigPatchDisabledRuleIdsList: S.Schema<WafConfigPatchDisabledRuleIdsList>;
 /** Ids of WAF Collections to mark as enabled */
 export type WafConfigPatchEnabledRuleCollectionIdsList = Array<string>;
-export declare const WafConfigPatchEnabledRuleCollectionIdsList: S.Schema<WafConfigPatchEnabledRuleCollectionIdsList>;
 /** Ids of WAF Rule Groups to mark as enabled */
 export type WafConfigPatchEnabledRuleGroupIdsList = Array<string>;
-export declare const WafConfigPatchEnabledRuleGroupIdsList: S.Schema<WafConfigPatchEnabledRuleGroupIdsList>;
 /** Ids of WAF Rules that are **explicitly** enabled for this distribution. */
 export type WafConfigPatchEnabledRuleIdsList = Array<string>;
-export declare const WafConfigPatchEnabledRuleIdsList: S.Schema<WafConfigPatchEnabledRuleIdsList>;
 /** Ids of WAF Collections to mark as log Only. */
 export type WafConfigPatchLogOnlyRuleCollectionIdsList = Array<string>;
-export declare const WafConfigPatchLogOnlyRuleCollectionIdsList: S.Schema<WafConfigPatchLogOnlyRuleCollectionIdsList>;
 /** Ids of WAF Rule Groups to mark as log Only. */
 export type WafConfigPatchLogOnlyRuleGroupIdsList = Array<string>;
-export declare const WafConfigPatchLogOnlyRuleGroupIdsList: S.Schema<WafConfigPatchLogOnlyRuleGroupIdsList>;
 /** Ids of WAF Rules that are **explicitly** marked as Log Only for this distribution. */
 export type WafConfigPatchLogOnlyRuleIdsList = Array<string>;
-export declare const WafConfigPatchLogOnlyRuleIdsList: S.Schema<WafConfigPatchLogOnlyRuleIdsList>;
 /** Modify the WAF Configuration ## WAF Rules You can modify the set of enabled, disabled and log-only Rules by modifying these 9 properties: - enabledRuleIds - disabledRuleIds - logOnlyRuleIds - enabledRuleGroupIds - disabledRuleGroupIds - logOnlyRuleGroupIds - enabledRuleCollectionIds - disabledRuleCollectionIds - logOnlyRuleCollectionIds Please inquire the `WafConfig` Description on how the effective configuration is determined. For patching, if an ID is already used in one of the properties, it will be removed (and effectively moved) to the new property. If patching multiple properties with the same ID (e.g. writing `@builtin/crs/response` to `logOnlyRuleCollectionIds` and `enabledRuleCollectionIds`), the request will be rejected with a 400. */
 export interface WafConfigPatch {
     allowedHttpMethods?: WafConfigPatchAllowedHttpMethodsList;
@@ -1105,7 +905,6 @@ export interface WafConfigPatch {
     paranoiaLevel?: WafParanoiaLevel | (string & {});
     type?: WafType | (string & {});
 }
-export declare const WafConfigPatch: S.Schema<WafConfigPatch>;
 export interface ConfigPatch {
     backend?: ConfigPatchBackend;
     /** Restricts access to your content based on country. We use the ISO 3166-1 alpha-2 standard for country codes (e.g., DE, ES, GB). This setting blocks users from the specified countries. */
@@ -1130,7 +929,6 @@ export interface ConfigPatch {
     tls?: TlsConfigPatch;
     waf?: WafConfigPatch;
 }
-export declare const ConfigPatch: S.Schema<ConfigPatch>;
 export interface PatchDistributionRequest {
     /** Your STACKIT Project Id */
     projectId: string;
@@ -1139,11 +937,9 @@ export interface PatchDistributionRequest {
     /** While optional, it is greatly encouraged to provide an `intentId`. This is used to deduplicate requests. If multiple modifying requests with the same `intentId` for a given `projectId` are received, all but the first request are dropped. */
     intentId?: string;
 }
-export declare const PatchDistributionRequest: S.Schema<PatchDistributionRequest>;
 export interface PatchDistributionResponse {
     distribution: Distribution;
 }
-export declare const PatchDistributionResponse: S.Schema<PatchDistributionResponse>;
 export interface PurgeCacheRequest {
     /** Your STACKIT Project Id */
     projectId: string;
@@ -1151,12 +947,9 @@ export interface PurgeCacheRequest {
     /** Defines an optional path. If this is set, a granular purge is done. If missing, the entire cache is invalidated. During a granular cache purge, only the provided path is purged. Please do not that for example `/some/path` and `/some/path.txt` are considered different paths. */
     path?: string;
 }
-export declare const PurgeCacheRequest: S.Schema<PurgeCacheRequest>;
 export type PurgeCacheResponse2 = unknown;
-export declare const PurgeCacheResponse2: S.Schema<PurgeCacheResponse2>;
 /** This is returned when no custom certificate is used. We provision and manage a Let's Encrypt Certificate for you */
 export type PutCustomDomainManagedCertificate = GetCustomDomainManagedCertificate;
-export declare const PutCustomDomainManagedCertificate: S.Schema<GetCustomDomainManagedCertificate>;
 /** Returned if a custom certificate is used. Response does not contain the certificate or key. */
 export interface PutCustomDomainCustomCertificate {
     /** base64-encoded PEM-encoded certificate */
@@ -1167,10 +960,8 @@ export interface PutCustomDomainCustomCertificate {
     skipDnsCheck?: boolean;
     type: string;
 }
-export declare const PutCustomDomainCustomCertificate: S.Schema<PutCustomDomainCustomCertificate>;
 /** Pass a custom certificate to be served by the CDN when calling the custom domain. Will use a managed certificate when omitted */
 export type PutCustomDomainRequestCertificate = GetCustomDomainManagedCertificate | PutCustomDomainCustomCertificate;
-export declare const PutCustomDomainRequestCertificate: S.Schema<PutCustomDomainRequestCertificate>;
 export interface PutCustomDomainRequest {
     /** Your STACKIT Project Id */
     projectId: string;
@@ -1181,16 +972,13 @@ export interface PutCustomDomainRequest {
     /** While optional, it is greatly encouraged to provide an `intentId`. This is used to deduplicate requests. If multiple modifying Requests with the same `intentId` for a given `projectId` are received, all but the first request are dropped. */
     intentId?: string;
 }
-export declare const PutCustomDomainRequest: S.Schema<PutCustomDomainRequest>;
 /** Pass a custom certificate to be served by the CDN when calling the custom domain. Will use a managed certificate when omitted */
 export type PutCustomDomainResponseCertificate = GetCustomDomainManagedCertificate | GetCustomDomainCustomCertificate;
-export declare const PutCustomDomainResponseCertificate: S.Schema<PutCustomDomainResponseCertificate>;
 export interface PutCustomDomainResponse {
     /** Pass a custom certificate to be served by the CDN when calling the custom domain. Will use a managed certificate when omitted */
     certificate?: PutCustomDomainResponseCertificate;
     customDomain: CustomDomain;
 }
-export declare const PutCustomDomainResponse: S.Schema<PutCustomDomainResponse>;
 export type CreateDistributionError = BadRequest | UnprocessableEntity | StackitOpError;
 /** Create new distribution CreateDistribution will create a new CDN distribution */
 export declare const createDistribution: API.OperationMethod<CreateDistributionRequest, CreateDistributionResponse, CreateDistributionError, StackitOpContext>;