declare const FLUI_API_VERSION: "flui.cloud/v1beta1"; declare const FLUI_API_VERSION_LEGACY: "flui/v1"; type FluiApiVersion = typeof FLUI_API_VERSION | typeof FLUI_API_VERSION_LEGACY; /** * Definitions both manifest kinds carry, field for field. * * `healthcheck` and `smokeTest` describe things the *pipeline* does — a probe inside the container * and a gate on the host — not things a packager does for software they did not write. So they * belong to whoever is deploying, whichever kind they wrote it in. The two JSON Schemas each keep * their own copy (they must stay standalone for ajv) and a parity test asserts the copies are * deep-equal; these types are the single copy on the TypeScript side. */ interface FluiHealthcheck { /** Omitted means `http` — a healthcheck declaring only `path` is complete. */ type?: 'http' | 'tcp' | 'exec'; /** Required for an http probe: a real route that returns 2xx. */ path?: string; port?: number; /** Required for an exec probe. */ command?: string[]; /** * Extra HTTP request headers for the probe (http type only). Use to send a * trusted `Host` (e.g. localhost) to apps that reject unknown Hosts on their * health path — the kubelet otherwise sends the pod IP, which such apps 400. */ httpHeaders?: Record; initialDelay?: string; interval?: string; timeout?: string; retries?: number; } interface FluiSmokeTestHttp { type: 'http'; path?: string; expectedStatus?: number; timeoutSeconds?: number; retries?: number; } interface FluiSmokeTestTcp { type: 'tcp'; port?: number; timeoutSeconds?: number; retries?: number; } interface FluiSmokeTestScript { type: 'script'; inline?: string; file?: string; shell?: string; timeoutSeconds?: number; retries?: number; } interface FluiSmokeTestSkip { type: 'skip'; reason?: string; } type FluiSmokeTest = FluiSmokeTestHttp | FluiSmokeTestTcp | FluiSmokeTestScript | FluiSmokeTestSkip; /** * What the APPLICATION needs, which `domain.tls` cannot say: `tls` is the operator asking for a * certificate. `required` means the app does not work over plain HTTP at all — a client refuses a * deploy that would not be reachable over HTTPS; `recommended` warns and proceeds; `none`, like an * absent field, means nothing is said. */ type FluiHttpsRequirement = 'required' | 'recommended' | 'none'; declare enum ApplicationKind { DATABASE = "DATABASE", APPLICATION = "APPLICATION", TOOL = "TOOL", SYSTEM = "SYSTEM" } declare enum CatalogAppType { STANDALONE = "standalone", BUILDING_BLOCK = "building-block", COMPOSED = "composed" } declare enum ScalingPolicyPreset { CONSERVATIVE = "conservative", BALANCED = "balanced", AGGRESSIVE = "aggressive" } declare enum VpaMode { OFF = "Off", INITIAL = "Initial", RECREATE = "Recreate", AUTO = "Auto" } interface CatalogAppManifest { kind: 'CatalogApp'; apiVersion: FluiApiVersion; metadata: CatalogMetadata; spec: CatalogSpec; } interface CatalogMetadata { id: string; name: string; description?: string; appKind: ApplicationKind; category: string; tags?: string[]; license?: string; version: string; icon?: string; links?: CatalogLinks; ratings?: CatalogRatings; alternativeTo?: string[]; maintainedAt?: string; entrypointPath?: string; clientFor?: string[]; clientDefaultFor?: string[]; draft?: boolean; } interface CatalogLinks { website?: string; docs?: string; source?: string; } interface CatalogRatings { wow?: number; utility?: number; euFit?: number; community?: number; } type CatalogSpec = CatalogSpecStandalone | CatalogSpecBuildingBlock | CatalogSpecComposed; type CatalogExposure = 'public' | 'internal'; type CatalogPersistenceScope = 'shared' | 'dedicated'; interface CatalogPersistence { scope: CatalogPersistenceScope; } interface CatalogSpecStandalone { type: CatalogAppType.STANDALONE; image: CatalogImageSource; ports: CatalogPort[]; volumes?: CatalogVolume[]; persistence?: CatalogPersistence; env: CatalogEnvVar[]; resources: CatalogResources; scaling: CatalogScaling; healthcheck?: CatalogHealthcheck; exposure?: CatalogExposure; privatizable?: boolean; domain?: CatalogDomainSpec; auth?: CatalogAuth; access?: CatalogAccess; postInstall?: CatalogPostInstallStep[]; startCommand?: string; linkedBuildingBlocks?: CatalogLinkedBuildingBlock[]; dependencies?: CatalogDependency[]; smokeTest?: CatalogSmokeTest; } interface CatalogLinkedBuildingBlock { ref: string; envMapping: CatalogLinkedEnv[]; } interface CatalogLinkedEnv { name: string; fromService?: 'host' | 'port'; fromBBEnv?: string; value?: string; } interface CatalogSpecBuildingBlock { type: CatalogAppType.BUILDING_BLOCK; /** How a client reaches this block — declared once here, not restated per client. */ connection?: { url: string; }; image: CatalogImageSource; ports: CatalogPort[]; volumes?: CatalogVolume[]; persistence?: CatalogPersistence; env: CatalogEnvVar[]; resources: CatalogResources; scaling: CatalogScaling; healthcheck: CatalogHealthcheck; startCommand?: string; auth?: CatalogAuth; access?: CatalogAccess; postInstall?: CatalogPostInstallStep[]; smokeTest?: CatalogSmokeTest; dependencies?: CatalogDependency[]; } interface CatalogSpecComposed { type: CatalogAppType.COMPOSED; scalingPolicy?: CatalogScalingPolicy; networking?: CatalogComposedNetworking; domain?: CatalogDomainSpec; auth?: CatalogAuth; access?: CatalogAccess; /** Install-time feature toggles; gate components & postInstall via `when.option`. */ options?: CatalogOption[]; postInstall?: CatalogPostInstallStep[]; components: CatalogComponent[]; } interface CatalogOption { key: string; label: string; description?: string; /** Pre-selected state when the installer offers the toggle. */ default?: boolean; } type CatalogAuthMode = 'oidc' | 'proxy' | 'native' | 'none'; interface CatalogAuth { /** Single fixed mode (legacy/shorthand). Prefer `modes` + `default`. */ mode?: CatalogAuthMode; /** Methods the app offers; the installer lets the user pick one. */ modes?: CatalogAuthMode[]; /** Pre-selected method at install time when `modes` is offered. */ default?: CatalogAuthMode; oidc?: CatalogAuthOidc; proxy?: CatalogAuthProxy; } interface CatalogAuthOidc { redirectPath?: string; /** Redirect/callback paths registered on the IdP client (host added at install). */ redirectPaths?: string[]; scopes?: string[]; /** Env-based injection: maps OIDC values to the app's env var names. */ envMapping?: { issuerUrl?: string; clientId?: string; clientSecret?: string; enabledFlag?: string; }; /** File-based injection: render `template` (with {{oidc.*}}) to `path`, point `env` at it. */ configFile?: { path: string; env: string; template: string; }; } interface CatalogAuthProxy { headerMapping?: Record; } /** * How a user logs into the app after install. Orthogonal to `auth` (which is * *how* authentication works): `access` is *what to hand the user* — the login * URL and the admin credentials, wherever they come from (a value the user set, * a secret generated on the host, or a default baked into the image). */ type CatalogAccessMode = 'credentials' | 'firstVisit' | 'none'; interface CatalogAccess { /** Defaults to 'credentials' when the block is present. `firstVisit`: no * account exists until the first visitor claims it (e.g. WordPress installer, * Immich native sign-up). `none`: nothing to hand the user. */ mode?: CatalogAccessMode; /** Login path under the app URL. Falls back to `metadata.entrypointPath`, then `/`. */ path?: string; username?: CatalogAccessValue; password?: CatalogAccessValue; /** Shown with the credentials, e.g. "Change this after first login." */ note?: string; } /** One credential part: an env reference (userInput/generate/default) or a fixed value. */ interface CatalogAccessValue { /** Env var name whose runtime value is the credential (read back on reveal). */ fromEnv?: string; /** Composed apps: the component declaring that env (default: the primary/exposed one). */ component?: string; /** Value baked into the image (a fixed default, e.g. `umami`/`umami`). */ value?: string; } interface CatalogPostInstallStep { name: string; description?: string; /** Gate: step runs only if the install context matches (AND of keys). */ when?: { authMode?: CatalogAuthMode | CatalogAuthMode[]; /** Runs only if this install-time option (spec.options[].key) is enabled. */ option?: string; }; http?: { method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'; /** Relative to the app's primary endpoint URL. */ path: string; headers?: Record; body?: string; /** Status codes treated as success (e.g. [200,201,400] to tolerate "exists"). */ expectStatus?: number[]; }; /** * Runs a command inside the primary component's pod. For apps configured via * a CLI rather than HTTP/config-file (e.g. Nextcloud `occ`). Args are templated * ({{install.resolvedFqdn}}, {{oidc.*}}, {{generate.password}}). */ exec?: { command: string[]; container?: string; }; } interface CatalogComponent { name: string; image: CatalogImageSource; ports?: CatalogPort[]; volumes?: CatalogVolume[]; persistence?: CatalogPersistence; env: CatalogEnvVar[]; resources: CatalogResources; scaling: CatalogScaling; healthcheck?: CatalogHealthcheck; dependsOn?: string[]; /** * Overrides the image CMD (run as `sh -c`). Use it to make a component * self-initializing: run idempotent setup (migrations, config) and `exec` * the image's original command, so every boot converges to a ready state. */ startCommand?: string; /** Component is created only if the gate matches (e.g. an optional feature). */ when?: { /** Created only if this install-time option (spec.options[].key) is enabled. */ option?: string; }; } interface CatalogComposedNetworking { internal: string; } interface CatalogScalingPolicy { mode: ScalingPolicyPreset; notifications?: CatalogScalingNotifications; } interface CatalogScalingNotifications { onScaleUp?: boolean; onOOMKill?: boolean; onScaleDown?: boolean; onVerticalResize?: boolean; } interface CatalogImageSource { registry?: string; repository?: string; tag?: string; credentials?: CatalogImageCredentials; source?: CatalogImageBuildSource; } interface CatalogImageCredentials { type: 'registry' | 'git-token'; secretRef: string; } interface CatalogImageBuildSource { type: 'git'; url: string; branch: string; dockerfile?: string; } interface CatalogPort { name: string; internal: number; expose: boolean; /** * `https`: the container speaks TLS itself (usually self-signed) and cannot be * served plain HTTP — the ingress proxies to it over TLS without verifying the * upstream certificate. Routing-wise it behaves like `http`. */ protocol?: 'http' | 'https' | 'tcp'; /** * How this HTTP port is published through the app's ingress hostname. Absent = * the primary component's first HTTP port becomes the root (`/`); a secondary * component's port needs an explicit `route` to be fronted (e.g. an API at * `/api` alongside the web UI). Ignored for non-HTTP ports. */ route?: CatalogPortRoute; } interface CatalogPortRoute { /** Path prefix under the app hostname, e.g. `/api`. Omitted or `/` = root. */ path?: string; /** Reserved: a dedicated subdomain instead of a path prefix (not yet supported). */ subdomain?: string; /** Strip the path prefix before proxying to the backend (default false). */ stripPrefix?: boolean; } interface CatalogVolume { name: string; mountPath: string; required?: boolean; size?: string; } interface CatalogEnvVar { name: string; value?: string; secret?: boolean; valueFrom?: CatalogValueFrom; userEditable?: boolean; description?: string; } type CatalogValueFrom = CatalogValueFromGenerate | CatalogValueFromSecretRef | CatalogValueFromUserInput; interface CatalogValueFromGenerate { generate: 'secret'; length: number; format?: 'base64url' | 'hex'; } interface CatalogValueFromSecretRef { secretRef: string; } interface CatalogValueFromUserInput { userInput: CatalogUserInputPrompt; } interface CatalogUserInputPrompt { label?: string; default?: string; sensitive?: boolean; /** * Whether the installer must collect a value. Independent of `sensitive` * (which only controls Secret vs plaintext storage). Defaults to `sensitive`: * a sensitive input is required unless this is explicitly `false`. Set `false` * on a sensitive input to make it optional, or `true` on a non-sensitive one * to require it. */ required?: boolean; /** * Inputs sharing a group id form an "at least one of" set: each member is * individually optional, but the installer must collect a value for at least * one member of the group. Mutually exclusive with `required`/`default`. */ group?: string; placeholder?: string; pattern?: string; patternDescription?: string; minLength?: number; maxLength?: number; confirm?: boolean; format?: 'email' | 'url' | 'password' | 'text'; } interface CatalogResources { requests?: CatalogResourceSpec; limits?: CatalogResourceSpec; } interface CatalogResourceSpec { cpu?: string; memory?: string; } interface CatalogScaling { horizontal: CatalogHpa; vertical: CatalogVpa; } interface CatalogHpa { enabled: boolean; min?: number; max?: number; metrics?: CatalogHpaMetric[]; behavior?: CatalogHpaBehavior; } interface CatalogHpaMetric { type: 'cpu' | 'memory' | 'custom'; target: CatalogHpaMetricTarget; } interface CatalogHpaMetricTarget { type: 'utilization' | 'averageValue'; value: number; } interface CatalogHpaBehavior { scaleUp?: CatalogHpaBehaviorPolicy; scaleDown?: CatalogHpaBehaviorPolicy; } interface CatalogHpaBehaviorPolicy { stabilizationWindow: string; step: number; } interface CatalogVpa { enabled: boolean; mode?: VpaMode; bounds?: CatalogVpaBounds; updatePolicy?: CatalogVpaUpdatePolicy; } interface CatalogVpaBounds { cpu?: CatalogVpaBoundsRange; memory?: CatalogVpaBoundsRange; } interface CatalogVpaBoundsRange { min: string; max: string; } interface CatalogVpaUpdatePolicy { trigger?: Array<'OOMKilled' | 'CPUThrottling'>; cooldown?: string; } /** Shared with `kind: Application` — see `FluiHealthcheck`. */ type CatalogHealthcheck = FluiHealthcheck; interface CatalogDomainSpec { auto?: boolean; userCustomizable?: boolean; tls?: boolean; hostnameMode?: 'ip' | 'domain'; certChallenge?: 'http-01' | 'dns-01'; certificateProvider?: 'lets-encrypt' | 'lets-encrypt-staging'; httpsRequirement?: FluiHttpsRequirement; } interface CatalogDependency { ref: string; as: string; required?: boolean; reuseExisting?: boolean; } /** Shared with `kind: Application` — see `FluiSmokeTest`. */ type CatalogSmokeTestHttp = FluiSmokeTestHttp; type CatalogSmokeTestTcp = FluiSmokeTestTcp; type CatalogSmokeTestScript = FluiSmokeTestScript; type CatalogSmokeTestSkip = FluiSmokeTestSkip; type CatalogSmokeTest = FluiSmokeTest; type EnvDelivery = 'runtime' | 'browser' | 'build'; interface ApplicationEnvValueFrom { generate?: 'secret'; length?: number; format?: 'base64url' | 'hex'; secretRef?: string; /** Reference to another Flui app in the same project; resolved per-environment. */ service?: string; /** Which attribute of the referenced service to inject. Defaults to `url`. */ key?: 'url' | 'host' | 'port'; userInput?: { label?: string; default?: string; sensitive?: boolean; placeholder?: string; format?: 'email' | 'url' | 'password' | 'text'; }; } /** An entry in the preferred map form of `deploy.env`. A bare string is shorthand for `{ value }`. */ interface ApplicationEnvEntry { value?: string; valueFrom?: ApplicationEnvValueFrom; delivery?: EnvDelivery; secret?: boolean; description?: string; } /** An entry in the deprecated array form of `deploy.env`. */ interface ApplicationManifestEnvVar { name: string; value?: string; secret?: boolean; valueFrom?: ApplicationEnvValueFrom; userEditable?: boolean; description?: string; } /** `deploy.env` accepts the map form (preferred) or the legacy array form. */ type ApplicationEnvMap = Record; type ApplicationEnv = ApplicationManifestEnvVar[] | ApplicationEnvMap; interface ApplicationManifestResources { profile?: 'nano' | 'small' | 'medium' | 'large' | 'xlarge'; requests?: { cpu?: string; memory?: string; }; limits?: { cpu?: string; memory?: string; }; } /** Shared with `kind: CatalogApp` — see `FluiHealthcheck`. */ type ApplicationManifestHealthcheck = FluiHealthcheck; interface ApplicationManifestScaling { min?: number; max?: number; } interface ApplicationManifestDomain { auto?: boolean; tls?: boolean; /** * Explicit FQDN to expose the app on (apex, or a subdomain on another zone). * Bypasses the cluster's assigned zone — taken verbatim. */ fqdn?: string; hostnameMode?: 'ip' | 'domain'; certChallenge?: 'http-01' | 'dns-01'; certificateProvider?: 'lets-encrypt' | 'lets-encrypt-staging'; userCustomizable?: boolean; httpsRequirement?: FluiHttpsRequirement; } interface ApplicationManifestVolume { name: string; mountPath: string; size?: string; } interface ApplicationManifestFile { /** Absolute path inside the container. */ path: string; /** Literal content; `{{env.NAME}}` interpolates a key declared in deploy.env. */ content: string; /** Octal mode on the host, e.g. "0600". */ mode?: string; } /** One environment variable of the application, computed from an attached service. */ interface ApplicationLinkedEnv { name: string; fromService?: 'host' | 'port' | 'url'; fromBBEnv?: string; value?: string; } /** A catalog building block rendered inside this application's own pod. */ interface ApplicationAttachedService { name: string; block: string; env: ApplicationLinkedEnv[]; /** CPU/memory ceiling for the attached service itself, not for the application. */ resources?: ApplicationManifestResources; } /** * The escape from one image per hostname: a value the build froze into its own output is * replaced at container start, before the application runs. */ interface ApplicationManifestReplaceAtStart { /** Absolute paths inside the container: a file, or a directory walked recursively. */ paths: string[]; /** Sentinel → value. The value takes `{{env.NAME}}`, `{{app.domain}}` and `{{app.scheme}}`. */ substitute: Record; } interface ApplicationManifestBuild { strategy?: 'dockerfile' | 'auto'; dockerfile?: string; context?: string; /** Docker build ARGs (--build-arg). Env-independent, baked into the image. */ args?: Record; /** Shell commands run in the checkout before the image build, each as its own CI step. */ prepare?: string[]; } /** * A per-environment partial override merged over the base spec. `build` is * deliberately absent (the same image is promoted across environments); env * overrides are literal values only. */ interface ApplicationEnvironmentProfile { branch?: string; deploy?: { resources?: ApplicationManifestResources; scaling?: ApplicationManifestScaling; domain?: ApplicationManifestDomain; }; env?: Record; } /** * How the workload is reached. `none` is the workload that does not listen — a worker, a queue * consumer — and is always declared, never inferred from a missing port. */ type ApplicationExposure = 'public' | 'internal' | 'none'; /** Everything in `deploy` that reads the same whether or not the workload listens. */ interface ApplicationDeployCommon { /** The post-deploy gate. Shared with `kind: CatalogApp`. */ smokeTest?: FluiSmokeTest; resources?: ApplicationManifestResources; scaling?: ApplicationManifestScaling; env?: ApplicationEnv; volumes?: ApplicationManifestVolume[]; /** Config files written beside the app and mounted read-only into the container. */ files?: ApplicationManifestFile[]; /** Building blocks attached to this application, inside its pod. */ services?: ApplicationAttachedService[]; /** Where the browser-facing runtime config file is written, and the global it assigns to. */ browserConfig?: { path: string; global?: string; }; startCommand?: string; /** Sentinel strings rewritten inside the image's own files, in the container, before the app starts. */ replaceAtStart?: ApplicationManifestReplaceAtStart; } /** A workload that listens: `port` is required, and a way in may be named. */ interface ApplicationDeployListening extends ApplicationDeployCommon { exposure?: 'public' | 'internal'; port: number; domain?: ApplicationManifestDomain; healthcheck?: ApplicationManifestHealthcheck; } /** * A workload that listens on nothing. The three fields that presuppose a listener are typed away * rather than left optional: `port?: number` would compile for a manifest the schema refuses, and * a type that accepts what the validator rejects is worse than no type at all. */ interface ApplicationDeploySilent extends ApplicationDeployCommon { exposure: 'none'; port?: never; domain?: never; /** An exec probe still works; an HTTP path does not, having no port to reach. */ healthcheck?: Omit & { path?: never; }; } type ApplicationDeploy = ApplicationDeployListening | ApplicationDeploySilent; interface ApplicationManifest { kind: 'Application'; apiVersion: FluiApiVersion; metadata: { name: string; }; build?: ApplicationManifestBuild; /** * Discriminated on `exposure`. Narrow before reading `port`, `domain` or `healthcheck.path`: * `if (manifest.deploy.exposure === 'none')` on one side, everything else on the other. */ deploy: ApplicationDeploy; environments?: Record; } type AccessRole = 'viewer' | 'editor' | 'manager'; type AccessPrincipalType = 'user' | 'group' | 'service_account'; interface AccessPrincipal { type: AccessPrincipalType; ref: string; } interface AccessSelector { slugs?: string[]; type?: 'system' | 'user'; /** App kind/category — open string, matched against the live (evolving) app taxonomy. */ kind?: string; clusterId?: string; clusterName?: string; provider?: string; project?: string; tags?: string[]; } type AccessScope = { type: 'global'; } | { type: 'section'; section: string; } | { type: 'cluster'; cluster: string; } | { type: 'selector'; selector: AccessSelector; }; interface AccessBinding { principal: AccessPrincipal; role: AccessRole; scope: AccessScope; } interface AccessPolicyManifest { kind: 'AccessPolicy'; apiVersion: FluiApiVersion; metadata: { name: string; description?: string; }; spec: { bindings: AccessBinding[]; }; } type FluiManifest = CatalogAppManifest | ApplicationManifest | AccessPolicyManifest; declare class FluiYamlParseError extends Error { constructor(message: string); } declare function parseYaml(rawYaml: string): unknown; declare function computeChecksum(value: unknown): string; declare function stableStringify(value: unknown): string; interface FluiValidationError { path: string; message: string; params?: Record; } /** * A non-fatal advisory. Emitted when a manifest uses a field the spec accepts * but the runtime does not yet apply (`x-flui-status: planned`). Warnings never * make a manifest invalid — they tell the author (or an LLM) the field will * have no effect at runtime yet. */ interface FluiValidationWarning { path: string; message: string; } type FluiValidationResult = { valid: true; manifest: FluiManifest; errors: []; warnings: FluiValidationWarning[]; } | { valid: false; manifest: null; errors: FluiValidationError[]; warnings: []; }; declare function validate(parsed: unknown): FluiValidationResult; declare const catalogAppSchema: Record; declare const applicationSchema: Record; declare const accessPolicySchema: Record; /** * The value a runtime must assume when a manifest omits `deploy.exposure`. * * Read from the schema rather than written again here, because `default` in JSON Schema is an * annotation: ajv does not fill it in (this package validates with `useDefaults` off, so a parsed * manifest carries `exposure: undefined` exactly as the author left it), and every consumer that * needs the resolved value has so far rebuilt it with its own literal. Two copies of a default is * two places for it to drift, and this particular default decides whether an application gets a * hostname, a certificate and a DNS record — a drift here is an application that runs and cannot * be reached. * * `application.test.ts` asserts this constant is the schema's own `default` and a member of its * own `enum`, so the schema stays the single source and this stays a read of it. */ declare const APPLICATION_EXPOSURE_DEFAULT: ApplicationExposure; export { APPLICATION_EXPOSURE_DEFAULT, type AccessBinding, type AccessPolicyManifest, type AccessPrincipal, type AccessPrincipalType, type AccessRole, type AccessScope, type AccessSelector, type ApplicationAttachedService, type ApplicationDeploy, type ApplicationDeployCommon, type ApplicationDeployListening, type ApplicationDeploySilent, type ApplicationEnv, type ApplicationEnvEntry, type ApplicationEnvMap, type ApplicationEnvValueFrom, type ApplicationEnvironmentProfile, type ApplicationExposure, ApplicationKind, type ApplicationLinkedEnv, type ApplicationManifest, type ApplicationManifestBuild, type ApplicationManifestDomain, type ApplicationManifestEnvVar, type ApplicationManifestFile, type ApplicationManifestHealthcheck, type ApplicationManifestReplaceAtStart, type ApplicationManifestResources, type ApplicationManifestScaling, type ApplicationManifestVolume, type CatalogAccess, type CatalogAccessMode, type CatalogAccessValue, type CatalogAppManifest, CatalogAppType, type CatalogAuth, type CatalogAuthMode, type CatalogAuthOidc, type CatalogAuthProxy, type CatalogComponent, type CatalogComposedNetworking, type CatalogDependency, type CatalogDomainSpec, type CatalogEnvVar, type CatalogExposure, type CatalogHealthcheck, type CatalogHpa, type CatalogHpaBehavior, type CatalogHpaBehaviorPolicy, type CatalogHpaMetric, type CatalogHpaMetricTarget, type CatalogImageBuildSource, type CatalogImageCredentials, type CatalogImageSource, type CatalogLinkedBuildingBlock, type CatalogLinkedEnv, type CatalogLinks, type CatalogMetadata, type CatalogOption, type CatalogPersistence, type CatalogPersistenceScope, type CatalogPort, type CatalogPortRoute, type CatalogPostInstallStep, type CatalogRatings, type CatalogResourceSpec, type CatalogResources, type CatalogScaling, type CatalogScalingNotifications, type CatalogScalingPolicy, type CatalogSmokeTest, type CatalogSmokeTestHttp, type CatalogSmokeTestScript, type CatalogSmokeTestSkip, type CatalogSmokeTestTcp, type CatalogSpec, type CatalogSpecBuildingBlock, type CatalogSpecComposed, type CatalogSpecStandalone, type CatalogUserInputPrompt, type CatalogValueFrom, type CatalogValueFromGenerate, type CatalogValueFromSecretRef, type CatalogValueFromUserInput, type CatalogVolume, type CatalogVpa, type CatalogVpaBounds, type CatalogVpaBoundsRange, type CatalogVpaUpdatePolicy, type EnvDelivery, FLUI_API_VERSION, FLUI_API_VERSION_LEGACY, type FluiApiVersion, type FluiHealthcheck, type FluiHttpsRequirement, type FluiManifest, type FluiSmokeTest, type FluiSmokeTestHttp, type FluiSmokeTestScript, type FluiSmokeTestSkip, type FluiSmokeTestTcp, type FluiValidationError, type FluiValidationResult, type FluiValidationWarning, FluiYamlParseError, ScalingPolicyPreset, VpaMode, accessPolicySchema, applicationSchema, catalogAppSchema, computeChecksum, parseYaml, stableStringify, validate };