@alienplatform/platform-api 3.3.32 → 3.3.33

package/esm/models/deploymentpendingpreparedstackdefaultunion.d.ts

@@ -0,0 +1,1986 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ExternalBindingUnion } from "./externalbindingunion.js";
+/**
+ * Deployment status in the deployment lifecycle.
+ *
+ * @remarks
+ *
+ * For observe-only deployments with no release or stack state, `Running`
+ * means the Operator is attached. Connectivity comes from `lastHeartbeatAt`;
+ * resource health comes from inventory and resource heartbeat data.
+ */
+export declare const DeploymentStatus: {
+    readonly Pending: "pending";
+    readonly PreflightsFailed: "preflights-failed";
+    readonly InitialSetup: "initial-setup";
+    readonly InitialSetupFailed: "initial-setup-failed";
+    readonly Provisioning: "provisioning";
+    readonly WaitingForMachines: "waiting-for-machines";
+    readonly WaitingForSecrets: "waiting-for-secrets";
+    readonly ProvisioningFailed: "provisioning-failed";
+    readonly Running: "running";
+    readonly RefreshFailed: "refresh-failed";
+    readonly UpdatePending: "update-pending";
+    readonly Updating: "updating";
+    readonly UpdateFailed: "update-failed";
+    readonly DeletePending: "delete-pending";
+    readonly Deleting: "deleting";
+    readonly DeleteFailed: "delete-failed";
+    readonly TeardownRequired: "teardown-required";
+    readonly TeardownFailed: "teardown-failed";
+    readonly Deleted: "deleted";
+    readonly Error: "error";
+};
+/**
+ * Deployment status in the deployment lifecycle.
+ *
+ * @remarks
+ *
+ * For observe-only deployments with no release or stack state, `Running`
+ * means the Operator is attached. Connectivity comes from `lastHeartbeatAt`;
+ * resource health comes from inventory and resource heartbeat data.
+ */
+export type DeploymentStatus = ClosedEnum<typeof DeploymentStatus>;
+/**
+ * Target platform for the deployment
+ */
+export declare const DeploymentPlatform: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+    readonly Kubernetes: "kubernetes";
+    readonly Machines: "machines";
+    readonly Local: "local";
+    readonly Test: "test";
+};
+/**
+ * Target platform for the deployment
+ */
+export type DeploymentPlatform = ClosedEnum<typeof DeploymentPlatform>;
+/**
+ * Underlying cloud platform for Kubernetes deployments.
+ */
+export declare const DeploymentBasePlatform: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+};
+/**
+ * Underlying cloud platform for Kubernetes deployments.
+ */
+export type DeploymentBasePlatform = ClosedEnum<typeof DeploymentBasePlatform>;
+export declare const DeploymentPlatformTest: {
+    readonly Test: "test";
+};
+export type DeploymentPlatformTest = ClosedEnum<typeof DeploymentPlatformTest>;
+/**
+ * Test platform environment information (mock)
+ */
+export type DeploymentEnvironmentInfoTest = {
+    /**
+     * Test identifier for this environment
+     */
+    testId: string;
+    platform: DeploymentPlatformTest;
+};
+export declare const DeploymentPlatformLocal: {
+    readonly Local: "local";
+};
+export type DeploymentPlatformLocal = ClosedEnum<typeof DeploymentPlatformLocal>;
+/**
+ * Local platform environment information
+ */
+export type DeploymentEnvironmentInfoLocal = {
+    /**
+     * Architecture (e.g., "x86_64", "aarch64")
+     */
+    arch: string;
+    /**
+     * Hostname of the machine running the deployment
+     */
+    hostname: string;
+    /**
+     * Operating system (e.g., "linux", "macos", "windows")
+     */
+    os: string;
+    platform: DeploymentPlatformLocal;
+};
+export declare const DeploymentPlatformAzure: {
+    readonly Azure: "azure";
+};
+export type DeploymentPlatformAzure = ClosedEnum<typeof DeploymentPlatformAzure>;
+/**
+ * Azure-specific environment information
+ */
+export type DeploymentEnvironmentInfoAzure = {
+    /**
+     * Azure location/region
+     */
+    location: string;
+    /**
+     * Azure subscription ID
+     */
+    subscriptionId: string;
+    /**
+     * Azure tenant ID
+     */
+    tenantId: string;
+    platform: DeploymentPlatformAzure;
+};
+export declare const DeploymentPlatformGcp: {
+    readonly Gcp: "gcp";
+};
+export type DeploymentPlatformGcp = ClosedEnum<typeof DeploymentPlatformGcp>;
+/**
+ * GCP-specific environment information
+ */
+export type DeploymentEnvironmentInfoGcp = {
+    /**
+     * GCP project ID (e.g., "my-project")
+     */
+    projectId: string;
+    /**
+     * GCP project number (e.g., "123456789012")
+     */
+    projectNumber: string;
+    /**
+     * GCP region
+     */
+    region: string;
+    platform: DeploymentPlatformGcp;
+};
+export declare const DeploymentPlatformAws: {
+    readonly Aws: "aws";
+};
+export type DeploymentPlatformAws = ClosedEnum<typeof DeploymentPlatformAws>;
+/**
+ * AWS-specific environment information
+ */
+export type DeploymentEnvironmentInfoAws = {
+    /**
+     * AWS account ID
+     */
+    accountId: string;
+    /**
+     * AWS region
+     */
+    region: string;
+    platform: DeploymentPlatformAws;
+};
+/**
+ * Cloud environment information
+ */
+export type DeploymentEnvironmentInfoUnion = DeploymentEnvironmentInfoGcp | DeploymentEnvironmentInfoAzure | DeploymentEnvironmentInfoLocal | DeploymentEnvironmentInfoAws | DeploymentEnvironmentInfoTest | string;
+/**
+ * Deployment-time resource allocation for a container. Omitted fields use release defaults.
+ */
+export type DeploymentContainers = {
+    /**
+     * CPU allocation in vCPUs.
+     */
+    cpu?: number | null | undefined;
+    /**
+     * Memory allocation, using binary units such as Mi or Gi.
+     */
+    memory?: string | null | undefined;
+    /**
+     * Persistent volume capacity per replica, in whole GiB. Omitted values
+     *
+     * @remarks
+     * use the release default. Existing volumes can only grow.
+     */
+    volumeSizeGib?: number | null | undefined;
+};
+/**
+ * Failure-domain policy selected for a compute pool.
+ */
+export type DeploymentFailureDomains2 = {
+    /**
+     * Concrete provider domains selected during setup.
+     *
+     * @remarks
+     * Empty delegates deterministic selection to the provider setup implementation.
+     */
+    selectedFailureDomains?: Array<string> | undefined;
+    /**
+     * Number of distinct failure domains across which new stateful replicas may be spread.
+     */
+    spread: number;
+};
+export type DeploymentFailureDomainsUnion2 = DeploymentFailureDomains2 | string;
+export type DeploymentPoolsAutoscale = {
+    failureDomains?: DeploymentFailureDomains2 | string | null | undefined;
+    /**
+     * Provider machine type selected for this deployment.
+     */
+    machine?: string | null | undefined;
+    /**
+     * Maximum machine count.
+     */
+    max: number;
+    /**
+     * Minimum machine count.
+     */
+    min: number;
+    mode: "autoscale";
+};
+/**
+ * Failure-domain policy selected for a compute pool.
+ */
+export type DeploymentFailureDomains1 = {
+    /**
+     * Concrete provider domains selected during setup.
+     *
+     * @remarks
+     * Empty delegates deterministic selection to the provider setup implementation.
+     */
+    selectedFailureDomains?: Array<string> | undefined;
+    /**
+     * Number of distinct failure domains across which new stateful replicas may be spread.
+     */
+    spread: number;
+};
+export type DeploymentFailureDomainsUnion1 = DeploymentFailureDomains1 | string;
+export type DeploymentPoolsFixed = {
+    failureDomains?: DeploymentFailureDomains1 | string | null | undefined;
+    /**
+     * Provider machine type selected for this deployment.
+     */
+    machine?: string | null | undefined;
+    /**
+     * Number of machines to run.
+     */
+    machines: number;
+    mode: "fixed";
+};
+/**
+ * User-selected deployment settings for one compute pool.
+ */
+export type DeploymentPoolsUnion = DeploymentPoolsFixed | DeploymentPoolsAutoscale;
+/**
+ * Deployment-time compute choices for Alien-managed compute pools.
+ *
+ * @remarks
+ *
+ * Application source declares portable pool requirements. This settings
+ * object stores the concrete choices made for one deployment, such as the
+ * provider machine type and selected machine counts.
+ */
+export type DeploymentCompute = {
+    /**
+     * Per-replica resources selected within each container's declared ranges.
+     */
+    containers?: {
+        [k: string]: DeploymentContainers;
+    } | undefined;
+    /**
+     * Selected compute choices keyed by pool ID.
+     */
+    pools?: {
+        [k: string]: DeploymentPoolsFixed | DeploymentPoolsAutoscale;
+    } | undefined;
+};
+export type DeploymentComputeUnion = DeploymentCompute | string;
+/**
+ * Deployment model: how updates are delivered to the remote environment.
+ */
+export declare const DeploymentDeploymentModel: {
+    readonly Push: "push";
+    readonly Pull: "pull";
+};
+/**
+ * Deployment model: how updates are delivered to the remote environment.
+ */
+export type DeploymentDeploymentModel = ClosedEnum<typeof DeploymentDeploymentModel>;
+export type DeploymentAws = {
+    certificateArn: string;
+};
+export type DeploymentAwsUnion = DeploymentAws | string;
+export type DeploymentAzureStackSettings = {
+    keyVaultCertificateId: string;
+    keyVaultResourceId?: string | null | undefined;
+};
+export type DeploymentAzureUnion = DeploymentAzureStackSettings | string;
+export type DeploymentGcpStackSettings = {
+    certificateName: string;
+};
+export type DeploymentGcpUnion = DeploymentGcpStackSettings | string;
+/**
+ * Namespace-scoped Kubernetes TLS Secret reference.
+ */
+export type DeploymentTlsSecretRef = {
+    /**
+     * Secret namespace. Defaults to the release namespace when omitted.
+     */
+    namespace?: string | null | undefined;
+    /**
+     * Secret name.
+     */
+    secretName: string;
+};
+export type DeploymentDomainsKubernetes = {
+    /**
+     * Namespace-scoped Kubernetes TLS Secret reference.
+     */
+    tlsSecretRef: DeploymentTlsSecretRef;
+};
+export type DeploymentDomainsKubernetesUnion = DeploymentDomainsKubernetes | string;
+/**
+ * Platform-specific certificate references for custom domains.
+ */
+export type DeploymentDomainsCertificate = {
+    aws?: DeploymentAws | string | null | undefined;
+    azure?: DeploymentAzureStackSettings | string | null | undefined;
+    gcp?: DeploymentGcpStackSettings | string | null | undefined;
+    kubernetes?: DeploymentDomainsKubernetes | string | null | undefined;
+};
+/**
+ * Custom domain configuration for a single resource.
+ */
+export type DeploymentCustomDomains = {
+    /**
+     * Platform-specific certificate references for custom domains.
+     */
+    certificate: DeploymentDomainsCertificate;
+    /**
+     * Fully qualified domain name to use.
+     */
+    domain: string;
+};
+export declare const DeploymentModeLoadBalancer: {
+    readonly LoadBalancer: "loadBalancer";
+};
+export type DeploymentModeLoadBalancer = ClosedEnum<typeof DeploymentModeLoadBalancer>;
+export type DeploymentPublicEndpointTargetLoadBalancer = {
+    /**
+     * DNS name or URL for the external load balancer.
+     */
+    cnameTarget: string;
+    mode: DeploymentModeLoadBalancer;
+};
+export declare const DeploymentModeMachineAddresses: {
+    readonly MachineAddresses: "machineAddresses";
+};
+export type DeploymentModeMachineAddresses = ClosedEnum<typeof DeploymentModeMachineAddresses>;
+export type DeploymentPublicEndpointTargetMachineAddresses = {
+    mode: DeploymentModeMachineAddresses;
+};
+export type DeploymentPublicEndpointTargetUnion = DeploymentPublicEndpointTargetLoadBalancer | DeploymentPublicEndpointTargetMachineAddresses | string;
+/**
+ * Domain configuration for the stack.
+ *
+ * @remarks
+ *
+ * When `custom_domains` is set, the specified resources use customer-provided
+ * domains and certificates. Otherwise, Alien auto-generates domains.
+ */
+export type DeploymentDomains = {
+    /**
+     * Custom domain configuration per resource ID.
+     */
+    customDomains?: {
+        [k: string]: DeploymentCustomDomains;
+    } | null | undefined;
+    publicEndpointTarget?: DeploymentPublicEndpointTargetLoadBalancer | DeploymentPublicEndpointTargetMachineAddresses | string | null | undefined;
+};
+export type DeploymentDomainsUnion = DeploymentDomains | string;
+/**
+ * Reachability of the deployment's public endpoints, fixed at setup.
+ */
+export declare const DeploymentEndpointAccess: {
+    readonly Internet: "internet";
+    readonly Private: "private";
+};
+/**
+ * Reachability of the deployment's public endpoints, fixed at setup.
+ */
+export type DeploymentEndpointAccess = ClosedEnum<typeof DeploymentEndpointAccess>;
+/**
+ * How heartbeat health checks are handled.
+ */
+export declare const DeploymentHeartbeats: {
+    readonly Off: "off";
+    readonly On: "on";
+};
+/**
+ * How heartbeat health checks are handled.
+ */
+export type DeploymentHeartbeats = ClosedEnum<typeof DeploymentHeartbeats>;
+/**
+ * Optional provider-specific identity for a cloud-backed Kubernetes cluster.
+ */
+export type DeploymentCloud = {
+    accountId?: string | null | undefined;
+    clusterId?: string | null | undefined;
+    clusterName?: string | null | undefined;
+    projectId?: string | null | undefined;
+    region?: string | null | undefined;
+    resourceGroup?: string | null | undefined;
+    subscriptionId?: string | null | undefined;
+};
+export type DeploymentCloudUnion = DeploymentCloud | string;
+/**
+ * Ownership model for the Kubernetes cluster.
+ */
+export declare const DeploymentOwnership: {
+    readonly Managed: "managed";
+    readonly Existing: "existing";
+    readonly External: "external";
+};
+/**
+ * Ownership model for the Kubernetes cluster.
+ */
+export type DeploymentOwnership = ClosedEnum<typeof DeploymentOwnership>;
+/**
+ * Kubernetes cluster setup settings.
+ */
+export type DeploymentCluster = {
+    cloud?: DeploymentCloud | string | null | undefined;
+    /**
+     * Namespace where the Alien chart and application resources run.
+     */
+    namespace?: string | null | undefined;
+    /**
+     * Ownership model for the Kubernetes cluster.
+     */
+    ownership: DeploymentOwnership;
+};
+export type DeploymentClusterUnion = DeploymentCluster | string;
+export type DeploymentCertificateNone2 = {
+    mode: "none";
+};
+export type DeploymentCertificateManagedTLSSecret2 = {
+    mode: "managedTlsSecret";
+    /**
+     * Secret name template. Runtime may substitute resource/deployment tokens.
+     */
+    secretNameTemplate: string;
+};
+export type DeploymentCertificateAwsAcmArn2 = {
+    /**
+     * Existing ACM certificate ARN.
+     */
+    certificateArn: string;
+    mode: "awsAcmArn";
+};
+export type DeploymentCertificateManagedAcmImport2 = {
+    mode: "managedAcmImport";
+    /**
+     * ACM region. Defaults to the deployment region when omitted.
+     */
+    region?: string | null | undefined;
+    /**
+     * Tags applied to runtime-imported ACM certificates.
+     */
+    tags?: {
+        [k: string]: string;
+    } | undefined;
+};
+/**
+ * Namespace-scoped Kubernetes TLS Secret reference.
+ */
+export type DeploymentCertificateTLSSecretRef2 = {
+    /**
+     * Secret namespace. Defaults to the release namespace when omitted.
+     */
+    namespace?: string | null | undefined;
+    /**
+     * Secret name.
+     */
+    secretName: string;
+    mode: "tlsSecretRef";
+};
+/**
+ * Certificate publication or reference mode for Kubernetes public endpoints.
+ */
+export type DeploymentCertificateUnion2 = DeploymentCertificateTLSSecretRef2 | DeploymentCertificateManagedAcmImport2 | DeploymentCertificateAwsAcmArn2 | DeploymentCertificateManagedTLSSecret2 | DeploymentCertificateNone2;
+export declare const DeploymentModeCustom: {
+    readonly Custom: "custom";
+};
+export type DeploymentModeCustom = ClosedEnum<typeof DeploymentModeCustom>;
+export declare const DeploymentProviderAzureApplicationGatewayForContainersEnum4: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+export type DeploymentProviderAzureApplicationGatewayForContainersEnum4 = ClosedEnum<typeof DeploymentProviderAzureApplicationGatewayForContainersEnum4>;
+export type DeploymentProviderAzureApplicationGatewayForContainers4 = {
+    /**
+     * Optional ALB name when using BYO Application Gateway resources.
+     */
+    albName?: string | null | undefined;
+    /**
+     * Optional ALB namespace when using BYO Application Gateway resources.
+     */
+    albNamespace?: string | null | undefined;
+    /**
+     * Public or internal frontend exposure.
+     */
+    frontend: string;
+    provider: DeploymentProviderAzureApplicationGatewayForContainersEnum4;
+};
+export declare const DeploymentProviderGkeGatewayEnum4: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type DeploymentProviderGkeGatewayEnum4 = ClosedEnum<typeof DeploymentProviderGkeGatewayEnum4>;
+export type DeploymentProviderGkeGateway4 = {
+    provider: DeploymentProviderGkeGatewayEnum4;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const DeploymentProviderAwsAlbEnum4: {
+    readonly AwsAlb: "awsAlb";
+};
+export type DeploymentProviderAwsAlbEnum4 = ClosedEnum<typeof DeploymentProviderAwsAlbEnum4>;
+export type DeploymentProviderAwsAlb4 = {
+    /**
+     * Optional ALB IP address type, such as `dualstack`.
+     */
+    ipAddressType?: string | null | undefined;
+    provider: DeploymentProviderAwsAlbEnum4;
+    /**
+     * Internet-facing or internal ALB scheme.
+     */
+    scheme: string;
+    /**
+     * Explicit subnet IDs when the profile cannot rely on controller discovery.
+     */
+    subnetIds?: Array<string> | undefined;
+    /**
+     * ALB target type, usually `ip`.
+     */
+    targetType: string;
+};
+export type DeploymentProviderUnion4 = DeploymentProviderAwsAlb4 | DeploymentProviderAzureApplicationGatewayForContainers4 | DeploymentProviderGkeGateway4 | string;
+/**
+ * Shared Gateway API route profile values.
+ */
+export type DeploymentRouteGateway2 = {
+    /**
+     * Annotations applied to route objects.
+     */
+    annotations?: {
+        [k: string]: string;
+    } | undefined;
+    /**
+     * Route controller identifier, for example a cloud Gateway controller.
+     */
+    controller?: string | null | undefined;
+    /**
+     * GatewayClass selected for generated Gateways.
+     */
+    gatewayClassName: string;
+    /**
+     * Labels applied to route objects.
+     */
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    /**
+     * Listener port, usually 443.
+     */
+    listenerPort: number;
+    provider?: DeploymentProviderAwsAlb4 | DeploymentProviderAzureApplicationGatewayForContainers4 | DeploymentProviderGkeGateway4 | string | null | undefined;
+    routeApi: "gateway";
+};
+export declare const DeploymentProviderAzureApplicationGatewayForContainersEnum3: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+export type DeploymentProviderAzureApplicationGatewayForContainersEnum3 = ClosedEnum<typeof DeploymentProviderAzureApplicationGatewayForContainersEnum3>;
+export type DeploymentProviderAzureApplicationGatewayForContainers3 = {
+    /**
+     * Optional ALB name when using BYO Application Gateway resources.
+     */
+    albName?: string | null | undefined;
+    /**
+     * Optional ALB namespace when using BYO Application Gateway resources.
+     */
+    albNamespace?: string | null | undefined;
+    /**
+     * Public or internal frontend exposure.
+     */
+    frontend: string;
+    provider: DeploymentProviderAzureApplicationGatewayForContainersEnum3;
+};
+export declare const DeploymentProviderGkeGatewayEnum3: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type DeploymentProviderGkeGatewayEnum3 = ClosedEnum<typeof DeploymentProviderGkeGatewayEnum3>;
+export type DeploymentProviderGkeGateway3 = {
+    provider: DeploymentProviderGkeGatewayEnum3;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const DeploymentProviderAwsAlbEnum3: {
+    readonly AwsAlb: "awsAlb";
+};
+export type DeploymentProviderAwsAlbEnum3 = ClosedEnum<typeof DeploymentProviderAwsAlbEnum3>;
+export type DeploymentProviderAwsAlb3 = {
+    /**
+     * Optional ALB IP address type, such as `dualstack`.
+     */
+    ipAddressType?: string | null | undefined;
+    provider: DeploymentProviderAwsAlbEnum3;
+    /**
+     * Internet-facing or internal ALB scheme.
+     */
+    scheme: string;
+    /**
+     * Explicit subnet IDs when the profile cannot rely on controller discovery.
+     */
+    subnetIds?: Array<string> | undefined;
+    /**
+     * ALB target type, usually `ip`.
+     */
+    targetType: string;
+};
+export type DeploymentProviderUnion3 = DeploymentProviderAwsAlb3 | DeploymentProviderAzureApplicationGatewayForContainers3 | DeploymentProviderGkeGateway3 | string;
+/**
+ * Shared Ingress route profile values.
+ */
+export type DeploymentRouteIngress2 = {
+    /**
+     * Annotations applied to route objects.
+     */
+    annotations?: {
+        [k: string]: string;
+    } | undefined;
+    /**
+     * Route controller identifier, for example `eks.amazonaws.com/alb`.
+     */
+    controller?: string | null | undefined;
+    /**
+     * `spec.ingressClassName` for generated Ingresses.
+     */
+    ingressClassName: string;
+    /**
+     * Labels applied to route objects.
+     */
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    provider?: DeploymentProviderAwsAlb3 | DeploymentProviderAzureApplicationGatewayForContainers3 | DeploymentProviderGkeGateway3 | string | null | undefined;
+    routeApi: "ingress";
+};
+/**
+ * Kubernetes route API selected for public endpoints.
+ */
+export type DeploymentRouteUnion2 = DeploymentRouteIngress2 | DeploymentRouteGateway2;
+export type DeploymentExposureCustom = {
+    /**
+     * Certificate publication or reference mode for Kubernetes public endpoints.
+     */
+    certificate: DeploymentCertificateTLSSecretRef2 | DeploymentCertificateManagedAcmImport2 | DeploymentCertificateAwsAcmArn2 | DeploymentCertificateManagedTLSSecret2 | DeploymentCertificateNone2;
+    /**
+     * Hostname routed by the Kubernetes public endpoint.
+     */
+    domain: string;
+    mode: DeploymentModeCustom;
+    /**
+     * Kubernetes route API selected for public endpoints.
+     */
+    route: DeploymentRouteIngress2 | DeploymentRouteGateway2;
+};
+export type DeploymentCertificateNone1 = {
+    mode: "none";
+};
+export type DeploymentCertificateManagedTLSSecret1 = {
+    mode: "managedTlsSecret";
+    /**
+     * Secret name template. Runtime may substitute resource/deployment tokens.
+     */
+    secretNameTemplate: string;
+};
+export type DeploymentCertificateAwsAcmArn1 = {
+    /**
+     * Existing ACM certificate ARN.
+     */
+    certificateArn: string;
+    mode: "awsAcmArn";
+};
+export type DeploymentCertificateManagedAcmImport1 = {
+    mode: "managedAcmImport";
+    /**
+     * ACM region. Defaults to the deployment region when omitted.
+     */
+    region?: string | null | undefined;
+    /**
+     * Tags applied to runtime-imported ACM certificates.
+     */
+    tags?: {
+        [k: string]: string;
+    } | undefined;
+};
+/**
+ * Namespace-scoped Kubernetes TLS Secret reference.
+ */
+export type DeploymentCertificateTLSSecretRef1 = {
+    /**
+     * Secret namespace. Defaults to the release namespace when omitted.
+     */
+    namespace?: string | null | undefined;
+    /**
+     * Secret name.
+     */
+    secretName: string;
+    mode: "tlsSecretRef";
+};
+/**
+ * Certificate publication or reference mode for Kubernetes public endpoints.
+ */
+export type DeploymentCertificateUnion1 = DeploymentCertificateTLSSecretRef1 | DeploymentCertificateManagedAcmImport1 | DeploymentCertificateAwsAcmArn1 | DeploymentCertificateManagedTLSSecret1 | DeploymentCertificateNone1;
+export declare const DeploymentModeGenerated: {
+    readonly Generated: "generated";
+};
+export type DeploymentModeGenerated = ClosedEnum<typeof DeploymentModeGenerated>;
+export declare const DeploymentProviderAzureApplicationGatewayForContainersEnum2: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+export type DeploymentProviderAzureApplicationGatewayForContainersEnum2 = ClosedEnum<typeof DeploymentProviderAzureApplicationGatewayForContainersEnum2>;
+export type DeploymentProviderAzureApplicationGatewayForContainers2 = {
+    /**
+     * Optional ALB name when using BYO Application Gateway resources.
+     */
+    albName?: string | null | undefined;
+    /**
+     * Optional ALB namespace when using BYO Application Gateway resources.
+     */
+    albNamespace?: string | null | undefined;
+    /**
+     * Public or internal frontend exposure.
+     */
+    frontend: string;
+    provider: DeploymentProviderAzureApplicationGatewayForContainersEnum2;
+};
+export declare const DeploymentProviderGkeGatewayEnum2: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type DeploymentProviderGkeGatewayEnum2 = ClosedEnum<typeof DeploymentProviderGkeGatewayEnum2>;
+export type DeploymentProviderGkeGateway2 = {
+    provider: DeploymentProviderGkeGatewayEnum2;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const DeploymentProviderAwsAlbEnum2: {
+    readonly AwsAlb: "awsAlb";
+};
+export type DeploymentProviderAwsAlbEnum2 = ClosedEnum<typeof DeploymentProviderAwsAlbEnum2>;
+export type DeploymentProviderAwsAlb2 = {
+    /**
+     * Optional ALB IP address type, such as `dualstack`.
+     */
+    ipAddressType?: string | null | undefined;
+    provider: DeploymentProviderAwsAlbEnum2;
+    /**
+     * Internet-facing or internal ALB scheme.
+     */
+    scheme: string;
+    /**
+     * Explicit subnet IDs when the profile cannot rely on controller discovery.
+     */
+    subnetIds?: Array<string> | undefined;
+    /**
+     * ALB target type, usually `ip`.
+     */
+    targetType: string;
+};
+export type DeploymentProviderUnion2 = DeploymentProviderAwsAlb2 | DeploymentProviderAzureApplicationGatewayForContainers2 | DeploymentProviderGkeGateway2 | string;
+/**
+ * Shared Gateway API route profile values.
+ */
+export type DeploymentRouteGateway1 = {
+    /**
+     * Annotations applied to route objects.
+     */
+    annotations?: {
+        [k: string]: string;
+    } | undefined;
+    /**
+     * Route controller identifier, for example a cloud Gateway controller.
+     */
+    controller?: string | null | undefined;
+    /**
+     * GatewayClass selected for generated Gateways.
+     */
+    gatewayClassName: string;
+    /**
+     * Labels applied to route objects.
+     */
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    /**
+     * Listener port, usually 443.
+     */
+    listenerPort: number;
+    provider?: DeploymentProviderAwsAlb2 | DeploymentProviderAzureApplicationGatewayForContainers2 | DeploymentProviderGkeGateway2 | string | null | undefined;
+    routeApi: "gateway";
+};
+export declare const DeploymentProviderAzureApplicationGatewayForContainersEnum1: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+export type DeploymentProviderAzureApplicationGatewayForContainersEnum1 = ClosedEnum<typeof DeploymentProviderAzureApplicationGatewayForContainersEnum1>;
+export type DeploymentProviderAzureApplicationGatewayForContainers1 = {
+    /**
+     * Optional ALB name when using BYO Application Gateway resources.
+     */
+    albName?: string | null | undefined;
+    /**
+     * Optional ALB namespace when using BYO Application Gateway resources.
+     */
+    albNamespace?: string | null | undefined;
+    /**
+     * Public or internal frontend exposure.
+     */
+    frontend: string;
+    provider: DeploymentProviderAzureApplicationGatewayForContainersEnum1;
+};
+export declare const DeploymentProviderGkeGatewayEnum1: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type DeploymentProviderGkeGatewayEnum1 = ClosedEnum<typeof DeploymentProviderGkeGatewayEnum1>;
+export type DeploymentProviderGkeGateway1 = {
+    provider: DeploymentProviderGkeGatewayEnum1;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const DeploymentProviderAwsAlbEnum1: {
+    readonly AwsAlb: "awsAlb";
+};
+export type DeploymentProviderAwsAlbEnum1 = ClosedEnum<typeof DeploymentProviderAwsAlbEnum1>;
+export type DeploymentProviderAwsAlb1 = {
+    /**
+     * Optional ALB IP address type, such as `dualstack`.
+     */
+    ipAddressType?: string | null | undefined;
+    provider: DeploymentProviderAwsAlbEnum1;
+    /**
+     * Internet-facing or internal ALB scheme.
+     */
+    scheme: string;
+    /**
+     * Explicit subnet IDs when the profile cannot rely on controller discovery.
+     */
+    subnetIds?: Array<string> | undefined;
+    /**
+     * ALB target type, usually `ip`.
+     */
+    targetType: string;
+};
+export type DeploymentProviderUnion1 = DeploymentProviderAwsAlb1 | DeploymentProviderAzureApplicationGatewayForContainers1 | DeploymentProviderGkeGateway1 | string;
+/**
+ * Shared Ingress route profile values.
+ */
+export type DeploymentRouteIngress1 = {
+    /**
+     * Annotations applied to route objects.
+     */
+    annotations?: {
+        [k: string]: string;
+    } | undefined;
+    /**
+     * Route controller identifier, for example `eks.amazonaws.com/alb`.
+     */
+    controller?: string | null | undefined;
+    /**
+     * `spec.ingressClassName` for generated Ingresses.
+     */
+    ingressClassName: string;
+    /**
+     * Labels applied to route objects.
+     */
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    provider?: DeploymentProviderAwsAlb1 | DeploymentProviderAzureApplicationGatewayForContainers1 | DeploymentProviderGkeGateway1 | string | null | undefined;
+    routeApi: "ingress";
+};
+/**
+ * Kubernetes route API selected for public endpoints.
+ */
+export type DeploymentRouteUnion1 = DeploymentRouteIngress1 | DeploymentRouteGateway1;
+export type DeploymentExposureGenerated = {
+    /**
+     * Certificate publication or reference mode for Kubernetes public endpoints.
+     */
+    certificate: DeploymentCertificateTLSSecretRef1 | DeploymentCertificateManagedAcmImport1 | DeploymentCertificateAwsAcmArn1 | DeploymentCertificateManagedTLSSecret1 | DeploymentCertificateNone1;
+    mode: DeploymentModeGenerated;
+    /**
+     * Kubernetes route API selected for public endpoints.
+     */
+    route: DeploymentRouteIngress1 | DeploymentRouteGateway1;
+};
+export declare const DeploymentModeDisabled: {
+    readonly Disabled: "disabled";
+};
+export type DeploymentModeDisabled = ClosedEnum<typeof DeploymentModeDisabled>;
+export type DeploymentExposureDisabled = {
+    mode: DeploymentModeDisabled;
+};
+export type DeploymentExposureUnion = DeploymentExposureCustom | DeploymentExposureGenerated | DeploymentExposureDisabled | string;
+/**
+ * Kubernetes runtime substrate configuration.
+ *
+ * @remarks
+ *
+ * This controls how setup chooses the cluster backing `Platform::Kubernetes`
+ * deployments. When omitted, cloud-backed Kubernetes deployments default to a
+ * managed cluster and generic/on-prem Kubernetes defaults to an external
+ * cluster.
+ */
+export type DeploymentKubernetes = {
+    cluster?: DeploymentCluster | string | null | undefined;
+    exposure?: DeploymentExposureCustom | DeploymentExposureGenerated | DeploymentExposureDisabled | string | null | undefined;
+};
+export type DeploymentKubernetesUnion = DeploymentKubernetes | string;
+export declare const DeploymentTypeByoVnetAzure: {
+    readonly ByoVnetAzure: "byo-vnet-azure";
+};
+export type DeploymentTypeByoVnetAzure = ClosedEnum<typeof DeploymentTypeByoVnetAzure>;
+export type DeploymentNetworkByoVnetAzure = {
+    /**
+     * Name of the dedicated classic Application Gateway subnet within the VNet.
+     */
+    applicationGatewaySubnetName?: string | null | undefined;
+    /**
+     * Name of the dedicated subnet that hosts Private Endpoints (e.g. for a
+     *
+     * @remarks
+     * Postgres Flexible Server). A Private Endpoint must not share the private
+     * subnet, which is already claimed by the Container Apps environment's
+     * `infrastructure_subnet_id`. Required only when the stack contains a
+     * Postgres resource; otherwise unused.
+     */
+    privateEndpointSubnetName?: string | null | undefined;
+    /**
+     * Name of the private subnet within the VNet
+     */
+    privateSubnetName: string;
+    /**
+     * Name of the public subnet within the VNet
+     */
+    publicSubnetName: string;
+    type: DeploymentTypeByoVnetAzure;
+    /**
+     * The full resource ID of the existing VNet
+     */
+    vnetResourceId: string;
+};
+export declare const DeploymentTypeByoVpcGcp: {
+    readonly ByoVpcGcp: "byo-vpc-gcp";
+};
+export type DeploymentTypeByoVpcGcp = ClosedEnum<typeof DeploymentTypeByoVpcGcp>;
+export type DeploymentNetworkByoVpcGcp = {
+    /**
+     * The name of the existing VPC network
+     */
+    networkName: string;
+    /**
+     * The region of the subnet
+     */
+    region: string;
+    /**
+     * The name of the subnet to use
+     */
+    subnetName: string;
+    type: DeploymentTypeByoVpcGcp;
+};
+export declare const DeploymentTypeByoVpcAws: {
+    readonly ByoVpcAws: "byo-vpc-aws";
+};
+export type DeploymentTypeByoVpcAws = ClosedEnum<typeof DeploymentTypeByoVpcAws>;
+export type DeploymentNetworkByoVpcAws = {
+    /**
+     * IDs of private subnets
+     */
+    privateSubnetIds: Array<string>;
+    /**
+     * IDs of public subnets (required for public ingress)
+     */
+    publicSubnetIds: Array<string>;
+    /**
+     * Optional security group IDs to use
+     */
+    securityGroupIds?: Array<string> | undefined;
+    type: DeploymentTypeByoVpcAws;
+    /**
+     * The ID of the existing VPC
+     */
+    vpcId: string;
+};
+export declare const DeploymentTypeCreate: {
+    readonly Create: "create";
+};
+export type DeploymentTypeCreate = ClosedEnum<typeof DeploymentTypeCreate>;
+export type DeploymentNetworkCreate = {
+    /**
+     * Number of availability zones (default: 2).
+     */
+    availabilityZones?: number | undefined;
+    /**
+     * VPC/VNet CIDR block. If not specified, auto-generated from stack ID
+     *
+     * @remarks
+     * to reduce conflicts (e.g., "10.{hash}.0.0/16").
+     */
+    cidr?: string | null | undefined;
+    type: DeploymentTypeCreate;
+};
+export declare const DeploymentTypeUseDefault: {
+    readonly UseDefault: "use-default";
+};
+export type DeploymentTypeUseDefault = ClosedEnum<typeof DeploymentTypeUseDefault>;
+export type DeploymentNetworkUseDefault = {
+    type: DeploymentTypeUseDefault;
+};
+export type DeploymentNetworkUnion = DeploymentNetworkByoVpcAws | DeploymentNetworkByoVpcGcp | DeploymentNetworkByoVnetAzure | DeploymentNetworkUseDefault | DeploymentNetworkCreate | string;
+/**
+ * Whether setup remains a separate administrator operation.
+ */
+export declare const DeploymentSetupManagement: {
+    readonly Manual: "manual";
+    readonly Automatic: "automatic";
+};
+/**
+ * Whether setup remains a separate administrator operation.
+ */
+export type DeploymentSetupManagement = ClosedEnum<typeof DeploymentSetupManagement>;
+/**
+ * How telemetry (logs, metrics, traces) is handled.
+ */
+export declare const DeploymentTelemetry: {
+    readonly Off: "off";
+    readonly Auto: "auto";
+    readonly ApprovalRequired: "approval-required";
+};
+/**
+ * How telemetry (logs, metrics, traces) is handled.
+ */
+export type DeploymentTelemetry = ClosedEnum<typeof DeploymentTelemetry>;
+/**
+ * How updates are delivered to the deployment.
+ */
+export declare const DeploymentUpdates: {
+    readonly Auto: "auto";
+    readonly ApprovalRequired: "approval-required";
+};
+/**
+ * How updates are delivered to the deployment.
+ */
+export type DeploymentUpdates = ClosedEnum<typeof DeploymentUpdates>;
+/**
+ * User-provided configuration (network, deployment model, approvals)
+ */
+export type DeploymentStackSettings = {
+    compute?: DeploymentCompute | string | null | undefined;
+    /**
+     * Deployment model: how updates are delivered to the remote environment.
+     */
+    deploymentModel?: DeploymentDeploymentModel | undefined;
+    domains?: DeploymentDomains | string | null | undefined;
+    /**
+     * Reachability of the deployment's public endpoints, fixed at setup.
+     */
+    endpointAccess?: DeploymentEndpointAccess | undefined;
+    externalBindings?: {
+        [k: string]: ExternalBindingUnion;
+    } | null | undefined;
+    /**
+     * How heartbeat health checks are handled.
+     */
+    heartbeats?: DeploymentHeartbeats | undefined;
+    kubernetes?: DeploymentKubernetes | string | null | undefined;
+    network?: DeploymentNetworkByoVpcAws | DeploymentNetworkByoVpcGcp | DeploymentNetworkByoVnetAzure | DeploymentNetworkUseDefault | DeploymentNetworkCreate | string | null | undefined;
+    /**
+     * Exact externally managed endpoint URLs, keyed by resource ID and endpoint name.
+     *
+     * @remarks
+     *
+     * This is intended for adopted Machines deployments whose DNS and certificates remain
+     * customer-owned. The platform passes these URLs to the runtime without creating or
+     * replacing DNS records or certificates.
+     */
+    publicEndpoints?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    /**
+     * Provider quota identities whose preflight failures become visible warnings
+     *
+     * @remarks
+     * for this deployment. Checks still run; deploy-time provider limits still apply.
+     * Unknown identities are rejected. An empty list restores normal blocking.
+     */
+    quotaWarningOverrides?: Array<string> | undefined;
+    /**
+     * Whether setup remains a separate administrator operation.
+     */
+    setupManagement?: DeploymentSetupManagement | undefined;
+    /**
+     * How telemetry (logs, metrics, traces) is handled.
+     */
+    telemetry?: DeploymentTelemetry | undefined;
+    /**
+     * How updates are delivered to the deployment.
+     */
+    updates?: DeploymentUpdates | undefined;
+};
+/**
+ * Represents the target cloud platform.
+ */
+export declare const DeploymentStackStatePlatform: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+    readonly Kubernetes: "kubernetes";
+    readonly Machines: "machines";
+    readonly Local: "local";
+    readonly Test: "test";
+};
+/**
+ * Represents the target cloud platform.
+ */
+export type DeploymentStackStatePlatform = ClosedEnum<typeof DeploymentStackStatePlatform>;
+/**
+ * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
+ */
+export type DeploymentStackStateConfig = {
+    /**
+     * The unique identifier for this specific resource instance. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]). Maximum 64 characters.
+     */
+    id: string;
+    /**
+     * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
+     */
+    type: string;
+    additionalProperties?: {
+        [k: string]: any | null;
+    } | undefined;
+};
+/**
+ * Represents the target cloud platform.
+ */
+export declare const DeploymentControllerPlatformEnum: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+    readonly Kubernetes: "kubernetes";
+    readonly Machines: "machines";
+    readonly Local: "local";
+    readonly Test: "test";
+};
+/**
+ * Represents the target cloud platform.
+ */
+export type DeploymentControllerPlatformEnum = ClosedEnum<typeof DeploymentControllerPlatformEnum>;
+export type DeploymentControllerPlatformUnion = DeploymentControllerPlatformEnum | string;
+/**
+ * Reference to a resource by its stable id and resource type.
+ */
+export type DeploymentStackStateDependency = {
+    id: string;
+    /**
+     * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
+     */
+    type: string;
+};
+/**
+ * Canonical error container that provides a structured way to represent errors
+ *
+ * @remarks
+ * with rich metadata including error codes, human-readable messages, context,
+ * and chaining capabilities for error propagation.
+ *
+ * This struct is designed to be both machine-readable and user-friendly,
+ * supporting serialization for API responses and detailed error reporting
+ * in distributed systems.
+ */
+export type DeploymentErrorStackState = {
+    /**
+     * A unique identifier for the type of error.
+     *
+     * @remarks
+     *
+     * This should be a short, machine-readable string that can be used
+     * by clients to programmatically handle different error types.
+     * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
+     */
+    code: string;
+    /**
+     * Additional diagnostic information about the error context.
+     *
+     * @remarks
+     *
+     * This optional field can contain structured data providing more details
+     * about the error, such as validation errors, request parameters that
+     * caused the issue, or other relevant context information.
+     */
+    context?: any | null | undefined;
+    /**
+     * Optional human-facing remediation hint.
+     */
+    hint?: string | null | undefined;
+    /**
+     * HTTP status code for this error.
+     *
+     * @remarks
+     *
+     * Used when converting the error to an HTTP response. If None, falls back to
+     * the error type's default status code or 500.
+     */
+    httpStatusCode?: number | null | undefined;
+    /**
+     * Indicates if this is an internal error that should not be exposed to users.
+     *
+     * @remarks
+     *
+     * When `true`, this error contains sensitive information or implementation
+     * details that should not be shown to end-users. Such errors should be
+     * logged for debugging but replaced with generic error messages in responses.
+     */
+    internal: boolean;
+    /**
+     * Human-readable error message.
+     *
+     * @remarks
+     *
+     * This message should be clear and actionable for developers or end-users,
+     * providing context about what went wrong and potentially how to fix it.
+     */
+    message: string;
+    /**
+     * Indicates whether the operation that caused the error should be retried.
+     *
+     * @remarks
+     *
+     * When `true`, the error is transient and the operation might succeed
+     * if attempted again. When `false`, retrying the same operation is
+     * unlikely to succeed without changes.
+     */
+    retryable: boolean;
+    /**
+     * The underlying error that caused this error, creating an error chain.
+     *
+     * @remarks
+     *
+     * This allows for proper error propagation and debugging by maintaining
+     * the full context of how an error occurred through multiple layers
+     * of an application.
+     */
+    source?: any | null | undefined;
+};
+export type DeploymentErrorUnion = DeploymentErrorStackState | string;
+/**
+ * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
+ */
+export declare const DeploymentLifecycleStackStateEnum: {
+    readonly Frozen: "frozen";
+    readonly Live: "live";
+};
+/**
+ * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
+ */
+export type DeploymentLifecycleStackStateEnum = ClosedEnum<typeof DeploymentLifecycleStackStateEnum>;
+export type DeploymentLifecycleUnion = DeploymentLifecycleStackStateEnum | string;
+/**
+ * Resource outputs that can hold output data for any resource type in the Alien system. All resource outputs share a common 'type' field with additional type-specific output properties.
+ */
+export type DeploymentOutputs = {
+    /**
+     * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
+     */
+    type: string;
+    additionalProperties?: {
+        [k: string]: any | null;
+    } | undefined;
+};
+export type DeploymentOutputsUnion = DeploymentOutputs | string;
+/**
+ * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
+ */
+export type DeploymentPreviousConfig = {
+    /**
+     * The unique identifier for this specific resource instance. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]). Maximum 64 characters.
+     */
+    id: string;
+    /**
+     * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
+     */
+    type: string;
+    additionalProperties?: {
+        [k: string]: any | null;
+    } | undefined;
+};
+export type DeploymentPreviousConfigUnion = DeploymentPreviousConfig | string;
+/**
+ * Represents the high-level status of a resource during its lifecycle.
+ */
+export declare const DeploymentStackStateStatus: {
+    readonly Pending: "pending";
+    readonly Provisioning: "provisioning";
+    readonly ProvisionFailed: "provision-failed";
+    readonly Running: "running";
+    readonly Updating: "updating";
+    readonly UpdateFailed: "update-failed";
+    readonly Deleting: "deleting";
+    readonly DeleteFailed: "delete-failed";
+    readonly TeardownRequired: "teardown-required";
+    readonly Deleted: "deleted";
+    readonly RefreshFailed: "refresh-failed";
+};
+/**
+ * Represents the high-level status of a resource during its lifecycle.
+ */
+export type DeploymentStackStateStatus = ClosedEnum<typeof DeploymentStackStateStatus>;
+/**
+ * Represents the state of a single resource within the stack for a specific platform.
+ */
+export type DeploymentStackStateResources = {
+    /**
+     * The platform-specific resource controller that manages this resource's lifecycle.
+     *
+     * @remarks
+     * This is None when the resource status is Pending.
+     * Stored as JSON to make the struct serializable and movable to alien-core.
+     */
+    internal?: any | null | undefined;
+    /**
+     * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
+     */
+    config: DeploymentStackStateConfig;
+    controllerPlatform?: DeploymentControllerPlatformEnum | string | null | undefined;
+    /**
+     * Complete list of dependencies for this resource, including infrastructure dependencies.
+     *
+     * @remarks
+     * This preserves the full dependency information from the stack definition.
+     */
+    dependencies?: Array<DeploymentStackStateDependency> | undefined;
+    error?: DeploymentErrorStackState | string | null | undefined;
+    /**
+     * Stores the controller state that failed, used for manual retry operations.
+     *
+     * @remarks
+     * This allows resuming from the exact point where the failure occurred.
+     * Stored as JSON to make the struct serializable and movable to alien-core.
+     */
+    lastFailedState?: any | null | undefined;
+    lifecycle?: DeploymentLifecycleStackStateEnum | string | null | undefined;
+    outputs?: DeploymentOutputs | string | null | undefined;
+    previousConfig?: DeploymentPreviousConfig | string | null | undefined;
+    /**
+     * Binding parameters for remote access.
+     *
+     * @remarks
+     * Only populated when the resource has `remote_access: true` in its ResourceEntry.
+     * This is the JSON serialization of the binding configuration (e.g., StorageBinding, VaultBinding).
+     * Populated by controllers during provisioning using get_binding_params().
+     */
+    remoteBindingParams?: any | null | undefined;
+    /**
+     * Tracks consecutive retry attempts for the current state transition.
+     */
+    retryAttempt?: number | undefined;
+    /**
+     * Represents the high-level status of a resource during its lifecycle.
+     */
+    status: DeploymentStackStateStatus;
+    /**
+     * The high-level type of the resource (e.g., Worker::RESOURCE_TYPE, Storage::RESOURCE_TYPE).
+     */
+    type: string;
+};
+/**
+ * State of infrastructure components managed by this deployment
+ */
+export type DeploymentStackState = {
+    /**
+     * Represents the target cloud platform.
+     */
+    platform: DeploymentStackStatePlatform;
+    /**
+     * A prefix used for resource naming to ensure uniqueness across deployments.
+     */
+    resourcePrefix: string;
+    /**
+     * The state of individual resources, keyed by resource ID.
+     */
+    resources: {
+        [k: string]: DeploymentStackStateResources;
+    };
+};
+/**
+ * The secret store a deployer writes a vault-native secret into.
+ */
+export declare const DeploymentStore: {
+    readonly AwsParameterStore: "aws-parameter-store";
+    readonly GcpSecretManager: "gcp-secret-manager";
+    readonly AzureKeyVault: "azure-key-vault";
+    readonly KubernetesSecret: "kubernetes-secret";
+    readonly LocalVault: "local-vault";
+};
+/**
+ * The secret store a deployer writes a vault-native secret into.
+ */
+export type DeploymentStore = ClosedEnum<typeof DeploymentStore>;
+/**
+ * Where a deployer writes a vault-native secret.
+ */
+export type DeploymentLocation = {
+    /**
+     * Command that writes the value, with `<VALUE>` in place of the secret.
+     */
+    cliCommand: string;
+    /**
+     * Cloud console page where the secret is created, when the store has one.
+     */
+    consoleUrl?: string | null | undefined;
+    /**
+     * Command that deletes the secret. Deleting a deployment keeps the
+     *
+     * @remarks
+     * secrets the deployer wrote, since Alien never owned their values.
+     */
+    deleteCommand?: string | null | undefined;
+    /**
+     * Full name of the secret in that store.
+     */
+    name: string;
+    /**
+     * The secret store a deployer writes a vault-native secret into.
+     */
+    store: DeploymentStore;
+    /**
+     * The Azure Key Vault that holds the secret. Other stores resolve `name`
+     *
+     * @remarks
+     * in the stack's own account or project.
+     */
+    vaultName?: string | null | undefined;
+};
+/**
+ * Whether a deployer secret slot holds a usable value. Alien learns this from
+ *
+ * @remarks
+ * metadata only and never reads the value.
+ */
+export declare const DeploymentRuntimeMetadataStatus: {
+    readonly Present: "present";
+    readonly Missing: "missing";
+    readonly Invalid: "invalid";
+};
+/**
+ * Whether a deployer secret slot holds a usable value. Alien learns this from
+ *
+ * @remarks
+ * metadata only and never reads the value.
+ */
+export type DeploymentRuntimeMetadataStatus = ClosedEnum<typeof DeploymentRuntimeMetadataStatus>;
+/**
+ * The state of one deployer secret slot, reported with the deployment.
+ */
+export type DeploymentDeployerSecret = {
+    /**
+     * Stack input id.
+     */
+    inputId: string;
+    /**
+     * The input's label.
+     */
+    label: string;
+    /**
+     * Where a deployer writes a vault-native secret.
+     */
+    location: DeploymentLocation;
+    /**
+     * Why the slot is invalid.
+     */
+    message?: string | null | undefined;
+    /**
+     * Whether the workload cannot start without it.
+     */
+    required: boolean;
+    /**
+     * Whether a deployer secret slot holds a usable value. Alien learns this from
+     *
+     * @remarks
+     * metadata only and never reads the value.
+     */
+    status: DeploymentRuntimeMetadataStatus;
+    /**
+     * The secret store's version of the present value (never the value or a
+     *
+     * @remarks
+     * hash of it). A new version reaches workloads with the next update.
+     */
+    version?: string | null | undefined;
+};
+/**
+ * Actor that owns structural work during the initial setup phase.
+ */
+export declare const DeploymentInitialSetupAuthority: {
+    readonly ImportedHandoff: "importedHandoff";
+    readonly DirectSetup: "directSetup";
+};
+/**
+ * Actor that owns structural work during the initial setup phase.
+ */
+export type DeploymentInitialSetupAuthority = ClosedEnum<typeof DeploymentInitialSetupAuthority>;
+export declare const DeploymentPendingPreparedStackTypeStringList: {
+    readonly StringList: "stringList";
+};
+export type DeploymentPendingPreparedStackTypeStringList = ClosedEnum<typeof DeploymentPendingPreparedStackTypeStringList>;
+export type DeploymentPendingPreparedStackDefaultStringList = {
+    type: DeploymentPendingPreparedStackTypeStringList;
+    /**
+     * String list default.
+     */
+    value: Array<string>;
+};
+export declare const DeploymentPendingPreparedStackTypeBoolean: {
+    readonly Boolean: "boolean";
+};
+export type DeploymentPendingPreparedStackTypeBoolean = ClosedEnum<typeof DeploymentPendingPreparedStackTypeBoolean>;
+export type DeploymentPendingPreparedStackDefaultBoolean = {
+    type: DeploymentPendingPreparedStackTypeBoolean;
+    /**
+     * Boolean default.
+     */
+    value: boolean;
+};
+export declare const DeploymentPendingPreparedStackTypeNumber: {
+    readonly Number: "number";
+};
+export type DeploymentPendingPreparedStackTypeNumber = ClosedEnum<typeof DeploymentPendingPreparedStackTypeNumber>;
+export type DeploymentPendingPreparedStackDefaultNumber = {
+    type: DeploymentPendingPreparedStackTypeNumber;
+    /**
+     * Number default.
+     */
+    value: string;
+};
+export declare const DeploymentPendingPreparedStackTypeString: {
+    readonly String: "string";
+};
+export type DeploymentPendingPreparedStackTypeString = ClosedEnum<typeof DeploymentPendingPreparedStackTypeString>;
+export type DeploymentPendingPreparedStackDefaultString = {
+    type: DeploymentPendingPreparedStackTypeString;
+    /**
+     * String default.
+     */
+    value: string;
+};
+export type DeploymentPendingPreparedStackDefaultUnion = DeploymentPendingPreparedStackDefaultString | DeploymentPendingPreparedStackDefaultNumber | DeploymentPendingPreparedStackDefaultBoolean | DeploymentPendingPreparedStackDefaultStringList | string;
+/** @internal */
+export declare const DeploymentStatus$inboundSchema: z.ZodEnum<typeof DeploymentStatus>;
+/** @internal */
+export declare const DeploymentPlatform$inboundSchema: z.ZodEnum<typeof DeploymentPlatform>;
+/** @internal */
+export declare const DeploymentBasePlatform$inboundSchema: z.ZodEnum<typeof DeploymentBasePlatform>;
+/** @internal */
+export declare const DeploymentPlatformTest$inboundSchema: z.ZodEnum<typeof DeploymentPlatformTest>;
+/** @internal */
+export declare const DeploymentEnvironmentInfoTest$inboundSchema: z.ZodType<DeploymentEnvironmentInfoTest, unknown>;
+export declare function deploymentEnvironmentInfoTestFromJSON(jsonString: string): SafeParseResult<DeploymentEnvironmentInfoTest, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPlatformLocal$inboundSchema: z.ZodEnum<typeof DeploymentPlatformLocal>;
+/** @internal */
+export declare const DeploymentEnvironmentInfoLocal$inboundSchema: z.ZodType<DeploymentEnvironmentInfoLocal, unknown>;
+export declare function deploymentEnvironmentInfoLocalFromJSON(jsonString: string): SafeParseResult<DeploymentEnvironmentInfoLocal, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPlatformAzure$inboundSchema: z.ZodEnum<typeof DeploymentPlatformAzure>;
+/** @internal */
+export declare const DeploymentEnvironmentInfoAzure$inboundSchema: z.ZodType<DeploymentEnvironmentInfoAzure, unknown>;
+export declare function deploymentEnvironmentInfoAzureFromJSON(jsonString: string): SafeParseResult<DeploymentEnvironmentInfoAzure, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPlatformGcp$inboundSchema: z.ZodEnum<typeof DeploymentPlatformGcp>;
+/** @internal */
+export declare const DeploymentEnvironmentInfoGcp$inboundSchema: z.ZodType<DeploymentEnvironmentInfoGcp, unknown>;
+export declare function deploymentEnvironmentInfoGcpFromJSON(jsonString: string): SafeParseResult<DeploymentEnvironmentInfoGcp, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPlatformAws$inboundSchema: z.ZodEnum<typeof DeploymentPlatformAws>;
+/** @internal */
+export declare const DeploymentEnvironmentInfoAws$inboundSchema: z.ZodType<DeploymentEnvironmentInfoAws, unknown>;
+export declare function deploymentEnvironmentInfoAwsFromJSON(jsonString: string): SafeParseResult<DeploymentEnvironmentInfoAws, SDKValidationError>;
+/** @internal */
+export declare const DeploymentEnvironmentInfoUnion$inboundSchema: z.ZodType<DeploymentEnvironmentInfoUnion, unknown>;
+export declare function deploymentEnvironmentInfoUnionFromJSON(jsonString: string): SafeParseResult<DeploymentEnvironmentInfoUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentContainers$inboundSchema: z.ZodType<DeploymentContainers, unknown>;
+export declare function deploymentContainersFromJSON(jsonString: string): SafeParseResult<DeploymentContainers, SDKValidationError>;
+/** @internal */
+export declare const DeploymentFailureDomains2$inboundSchema: z.ZodType<DeploymentFailureDomains2, unknown>;
+export declare function deploymentFailureDomains2FromJSON(jsonString: string): SafeParseResult<DeploymentFailureDomains2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentFailureDomainsUnion2$inboundSchema: z.ZodType<DeploymentFailureDomainsUnion2, unknown>;
+export declare function deploymentFailureDomainsUnion2FromJSON(jsonString: string): SafeParseResult<DeploymentFailureDomainsUnion2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPoolsAutoscale$inboundSchema: z.ZodType<DeploymentPoolsAutoscale, unknown>;
+export declare function deploymentPoolsAutoscaleFromJSON(jsonString: string): SafeParseResult<DeploymentPoolsAutoscale, SDKValidationError>;
+/** @internal */
+export declare const DeploymentFailureDomains1$inboundSchema: z.ZodType<DeploymentFailureDomains1, unknown>;
+export declare function deploymentFailureDomains1FromJSON(jsonString: string): SafeParseResult<DeploymentFailureDomains1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentFailureDomainsUnion1$inboundSchema: z.ZodType<DeploymentFailureDomainsUnion1, unknown>;
+export declare function deploymentFailureDomainsUnion1FromJSON(jsonString: string): SafeParseResult<DeploymentFailureDomainsUnion1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPoolsFixed$inboundSchema: z.ZodType<DeploymentPoolsFixed, unknown>;
+export declare function deploymentPoolsFixedFromJSON(jsonString: string): SafeParseResult<DeploymentPoolsFixed, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPoolsUnion$inboundSchema: z.ZodType<DeploymentPoolsUnion, unknown>;
+export declare function deploymentPoolsUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPoolsUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCompute$inboundSchema: z.ZodType<DeploymentCompute, unknown>;
+export declare function deploymentComputeFromJSON(jsonString: string): SafeParseResult<DeploymentCompute, SDKValidationError>;
+/** @internal */
+export declare const DeploymentComputeUnion$inboundSchema: z.ZodType<DeploymentComputeUnion, unknown>;
+export declare function deploymentComputeUnionFromJSON(jsonString: string): SafeParseResult<DeploymentComputeUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentDeploymentModel$inboundSchema: z.ZodEnum<typeof DeploymentDeploymentModel>;
+/** @internal */
+export declare const DeploymentAws$inboundSchema: z.ZodType<DeploymentAws, unknown>;
+export declare function deploymentAwsFromJSON(jsonString: string): SafeParseResult<DeploymentAws, SDKValidationError>;
+/** @internal */
+export declare const DeploymentAwsUnion$inboundSchema: z.ZodType<DeploymentAwsUnion, unknown>;
+export declare function deploymentAwsUnionFromJSON(jsonString: string): SafeParseResult<DeploymentAwsUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentAzureStackSettings$inboundSchema: z.ZodType<DeploymentAzureStackSettings, unknown>;
+export declare function deploymentAzureStackSettingsFromJSON(jsonString: string): SafeParseResult<DeploymentAzureStackSettings, SDKValidationError>;
+/** @internal */
+export declare const DeploymentAzureUnion$inboundSchema: z.ZodType<DeploymentAzureUnion, unknown>;
+export declare function deploymentAzureUnionFromJSON(jsonString: string): SafeParseResult<DeploymentAzureUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentGcpStackSettings$inboundSchema: z.ZodType<DeploymentGcpStackSettings, unknown>;
+export declare function deploymentGcpStackSettingsFromJSON(jsonString: string): SafeParseResult<DeploymentGcpStackSettings, SDKValidationError>;
+/** @internal */
+export declare const DeploymentGcpUnion$inboundSchema: z.ZodType<DeploymentGcpUnion, unknown>;
+export declare function deploymentGcpUnionFromJSON(jsonString: string): SafeParseResult<DeploymentGcpUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentTlsSecretRef$inboundSchema: z.ZodType<DeploymentTlsSecretRef, unknown>;
+export declare function deploymentTlsSecretRefFromJSON(jsonString: string): SafeParseResult<DeploymentTlsSecretRef, SDKValidationError>;
+/** @internal */
+export declare const DeploymentDomainsKubernetes$inboundSchema: z.ZodType<DeploymentDomainsKubernetes, unknown>;
+export declare function deploymentDomainsKubernetesFromJSON(jsonString: string): SafeParseResult<DeploymentDomainsKubernetes, SDKValidationError>;
+/** @internal */
+export declare const DeploymentDomainsKubernetesUnion$inboundSchema: z.ZodType<DeploymentDomainsKubernetesUnion, unknown>;
+export declare function deploymentDomainsKubernetesUnionFromJSON(jsonString: string): SafeParseResult<DeploymentDomainsKubernetesUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentDomainsCertificate$inboundSchema: z.ZodType<DeploymentDomainsCertificate, unknown>;
+export declare function deploymentDomainsCertificateFromJSON(jsonString: string): SafeParseResult<DeploymentDomainsCertificate, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCustomDomains$inboundSchema: z.ZodType<DeploymentCustomDomains, unknown>;
+export declare function deploymentCustomDomainsFromJSON(jsonString: string): SafeParseResult<DeploymentCustomDomains, SDKValidationError>;
+/** @internal */
+export declare const DeploymentModeLoadBalancer$inboundSchema: z.ZodEnum<typeof DeploymentModeLoadBalancer>;
+/** @internal */
+export declare const DeploymentPublicEndpointTargetLoadBalancer$inboundSchema: z.ZodType<DeploymentPublicEndpointTargetLoadBalancer, unknown>;
+export declare function deploymentPublicEndpointTargetLoadBalancerFromJSON(jsonString: string): SafeParseResult<DeploymentPublicEndpointTargetLoadBalancer, SDKValidationError>;
+/** @internal */
+export declare const DeploymentModeMachineAddresses$inboundSchema: z.ZodEnum<typeof DeploymentModeMachineAddresses>;
+/** @internal */
+export declare const DeploymentPublicEndpointTargetMachineAddresses$inboundSchema: z.ZodType<DeploymentPublicEndpointTargetMachineAddresses, unknown>;
+export declare function deploymentPublicEndpointTargetMachineAddressesFromJSON(jsonString: string): SafeParseResult<DeploymentPublicEndpointTargetMachineAddresses, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPublicEndpointTargetUnion$inboundSchema: z.ZodType<DeploymentPublicEndpointTargetUnion, unknown>;
+export declare function deploymentPublicEndpointTargetUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPublicEndpointTargetUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentDomains$inboundSchema: z.ZodType<DeploymentDomains, unknown>;
+export declare function deploymentDomainsFromJSON(jsonString: string): SafeParseResult<DeploymentDomains, SDKValidationError>;
+/** @internal */
+export declare const DeploymentDomainsUnion$inboundSchema: z.ZodType<DeploymentDomainsUnion, unknown>;
+export declare function deploymentDomainsUnionFromJSON(jsonString: string): SafeParseResult<DeploymentDomainsUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentEndpointAccess$inboundSchema: z.ZodEnum<typeof DeploymentEndpointAccess>;
+/** @internal */
+export declare const DeploymentHeartbeats$inboundSchema: z.ZodEnum<typeof DeploymentHeartbeats>;
+/** @internal */
+export declare const DeploymentCloud$inboundSchema: z.ZodType<DeploymentCloud, unknown>;
+export declare function deploymentCloudFromJSON(jsonString: string): SafeParseResult<DeploymentCloud, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCloudUnion$inboundSchema: z.ZodType<DeploymentCloudUnion, unknown>;
+export declare function deploymentCloudUnionFromJSON(jsonString: string): SafeParseResult<DeploymentCloudUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentOwnership$inboundSchema: z.ZodEnum<typeof DeploymentOwnership>;
+/** @internal */
+export declare const DeploymentCluster$inboundSchema: z.ZodType<DeploymentCluster, unknown>;
+export declare function deploymentClusterFromJSON(jsonString: string): SafeParseResult<DeploymentCluster, SDKValidationError>;
+/** @internal */
+export declare const DeploymentClusterUnion$inboundSchema: z.ZodType<DeploymentClusterUnion, unknown>;
+export declare function deploymentClusterUnionFromJSON(jsonString: string): SafeParseResult<DeploymentClusterUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCertificateNone2$inboundSchema: z.ZodType<DeploymentCertificateNone2, unknown>;
+export declare function deploymentCertificateNone2FromJSON(jsonString: string): SafeParseResult<DeploymentCertificateNone2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCertificateManagedTLSSecret2$inboundSchema: z.ZodType<DeploymentCertificateManagedTLSSecret2, unknown>;
+export declare function deploymentCertificateManagedTLSSecret2FromJSON(jsonString: string): SafeParseResult<DeploymentCertificateManagedTLSSecret2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCertificateAwsAcmArn2$inboundSchema: z.ZodType<DeploymentCertificateAwsAcmArn2, unknown>;
+export declare function deploymentCertificateAwsAcmArn2FromJSON(jsonString: string): SafeParseResult<DeploymentCertificateAwsAcmArn2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCertificateManagedAcmImport2$inboundSchema: z.ZodType<DeploymentCertificateManagedAcmImport2, unknown>;
+export declare function deploymentCertificateManagedAcmImport2FromJSON(jsonString: string): SafeParseResult<DeploymentCertificateManagedAcmImport2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCertificateTLSSecretRef2$inboundSchema: z.ZodType<DeploymentCertificateTLSSecretRef2, unknown>;
+export declare function deploymentCertificateTLSSecretRef2FromJSON(jsonString: string): SafeParseResult<DeploymentCertificateTLSSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCertificateUnion2$inboundSchema: z.ZodType<DeploymentCertificateUnion2, unknown>;
+export declare function deploymentCertificateUnion2FromJSON(jsonString: string): SafeParseResult<DeploymentCertificateUnion2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentModeCustom$inboundSchema: z.ZodEnum<typeof DeploymentModeCustom>;
+/** @internal */
+export declare const DeploymentProviderAzureApplicationGatewayForContainersEnum4$inboundSchema: z.ZodEnum<typeof DeploymentProviderAzureApplicationGatewayForContainersEnum4>;
+/** @internal */
+export declare const DeploymentProviderAzureApplicationGatewayForContainers4$inboundSchema: z.ZodType<DeploymentProviderAzureApplicationGatewayForContainers4, unknown>;
+export declare function deploymentProviderAzureApplicationGatewayForContainers4FromJSON(jsonString: string): SafeParseResult<DeploymentProviderAzureApplicationGatewayForContainers4, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderGkeGatewayEnum4$inboundSchema: z.ZodEnum<typeof DeploymentProviderGkeGatewayEnum4>;
+/** @internal */
+export declare const DeploymentProviderGkeGateway4$inboundSchema: z.ZodType<DeploymentProviderGkeGateway4, unknown>;
+export declare function deploymentProviderGkeGateway4FromJSON(jsonString: string): SafeParseResult<DeploymentProviderGkeGateway4, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderAwsAlbEnum4$inboundSchema: z.ZodEnum<typeof DeploymentProviderAwsAlbEnum4>;
+/** @internal */
+export declare const DeploymentProviderAwsAlb4$inboundSchema: z.ZodType<DeploymentProviderAwsAlb4, unknown>;
+export declare function deploymentProviderAwsAlb4FromJSON(jsonString: string): SafeParseResult<DeploymentProviderAwsAlb4, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderUnion4$inboundSchema: z.ZodType<DeploymentProviderUnion4, unknown>;
+export declare function deploymentProviderUnion4FromJSON(jsonString: string): SafeParseResult<DeploymentProviderUnion4, SDKValidationError>;
+/** @internal */
+export declare const DeploymentRouteGateway2$inboundSchema: z.ZodType<DeploymentRouteGateway2, unknown>;
+export declare function deploymentRouteGateway2FromJSON(jsonString: string): SafeParseResult<DeploymentRouteGateway2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderAzureApplicationGatewayForContainersEnum3$inboundSchema: z.ZodEnum<typeof DeploymentProviderAzureApplicationGatewayForContainersEnum3>;
+/** @internal */
+export declare const DeploymentProviderAzureApplicationGatewayForContainers3$inboundSchema: z.ZodType<DeploymentProviderAzureApplicationGatewayForContainers3, unknown>;
+export declare function deploymentProviderAzureApplicationGatewayForContainers3FromJSON(jsonString: string): SafeParseResult<DeploymentProviderAzureApplicationGatewayForContainers3, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderGkeGatewayEnum3$inboundSchema: z.ZodEnum<typeof DeploymentProviderGkeGatewayEnum3>;
+/** @internal */
+export declare const DeploymentProviderGkeGateway3$inboundSchema: z.ZodType<DeploymentProviderGkeGateway3, unknown>;
+export declare function deploymentProviderGkeGateway3FromJSON(jsonString: string): SafeParseResult<DeploymentProviderGkeGateway3, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderAwsAlbEnum3$inboundSchema: z.ZodEnum<typeof DeploymentProviderAwsAlbEnum3>;
+/** @internal */
+export declare const DeploymentProviderAwsAlb3$inboundSchema: z.ZodType<DeploymentProviderAwsAlb3, unknown>;
+export declare function deploymentProviderAwsAlb3FromJSON(jsonString: string): SafeParseResult<DeploymentProviderAwsAlb3, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderUnion3$inboundSchema: z.ZodType<DeploymentProviderUnion3, unknown>;
+export declare function deploymentProviderUnion3FromJSON(jsonString: string): SafeParseResult<DeploymentProviderUnion3, SDKValidationError>;
+/** @internal */
+export declare const DeploymentRouteIngress2$inboundSchema: z.ZodType<DeploymentRouteIngress2, unknown>;
+export declare function deploymentRouteIngress2FromJSON(jsonString: string): SafeParseResult<DeploymentRouteIngress2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentRouteUnion2$inboundSchema: z.ZodType<DeploymentRouteUnion2, unknown>;
+export declare function deploymentRouteUnion2FromJSON(jsonString: string): SafeParseResult<DeploymentRouteUnion2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentExposureCustom$inboundSchema: z.ZodType<DeploymentExposureCustom, unknown>;
+export declare function deploymentExposureCustomFromJSON(jsonString: string): SafeParseResult<DeploymentExposureCustom, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCertificateNone1$inboundSchema: z.ZodType<DeploymentCertificateNone1, unknown>;
+export declare function deploymentCertificateNone1FromJSON(jsonString: string): SafeParseResult<DeploymentCertificateNone1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCertificateManagedTLSSecret1$inboundSchema: z.ZodType<DeploymentCertificateManagedTLSSecret1, unknown>;
+export declare function deploymentCertificateManagedTLSSecret1FromJSON(jsonString: string): SafeParseResult<DeploymentCertificateManagedTLSSecret1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCertificateAwsAcmArn1$inboundSchema: z.ZodType<DeploymentCertificateAwsAcmArn1, unknown>;
+export declare function deploymentCertificateAwsAcmArn1FromJSON(jsonString: string): SafeParseResult<DeploymentCertificateAwsAcmArn1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCertificateManagedAcmImport1$inboundSchema: z.ZodType<DeploymentCertificateManagedAcmImport1, unknown>;
+export declare function deploymentCertificateManagedAcmImport1FromJSON(jsonString: string): SafeParseResult<DeploymentCertificateManagedAcmImport1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCertificateTLSSecretRef1$inboundSchema: z.ZodType<DeploymentCertificateTLSSecretRef1, unknown>;
+export declare function deploymentCertificateTLSSecretRef1FromJSON(jsonString: string): SafeParseResult<DeploymentCertificateTLSSecretRef1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentCertificateUnion1$inboundSchema: z.ZodType<DeploymentCertificateUnion1, unknown>;
+export declare function deploymentCertificateUnion1FromJSON(jsonString: string): SafeParseResult<DeploymentCertificateUnion1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentModeGenerated$inboundSchema: z.ZodEnum<typeof DeploymentModeGenerated>;
+/** @internal */
+export declare const DeploymentProviderAzureApplicationGatewayForContainersEnum2$inboundSchema: z.ZodEnum<typeof DeploymentProviderAzureApplicationGatewayForContainersEnum2>;
+/** @internal */
+export declare const DeploymentProviderAzureApplicationGatewayForContainers2$inboundSchema: z.ZodType<DeploymentProviderAzureApplicationGatewayForContainers2, unknown>;
+export declare function deploymentProviderAzureApplicationGatewayForContainers2FromJSON(jsonString: string): SafeParseResult<DeploymentProviderAzureApplicationGatewayForContainers2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderGkeGatewayEnum2$inboundSchema: z.ZodEnum<typeof DeploymentProviderGkeGatewayEnum2>;
+/** @internal */
+export declare const DeploymentProviderGkeGateway2$inboundSchema: z.ZodType<DeploymentProviderGkeGateway2, unknown>;
+export declare function deploymentProviderGkeGateway2FromJSON(jsonString: string): SafeParseResult<DeploymentProviderGkeGateway2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderAwsAlbEnum2$inboundSchema: z.ZodEnum<typeof DeploymentProviderAwsAlbEnum2>;
+/** @internal */
+export declare const DeploymentProviderAwsAlb2$inboundSchema: z.ZodType<DeploymentProviderAwsAlb2, unknown>;
+export declare function deploymentProviderAwsAlb2FromJSON(jsonString: string): SafeParseResult<DeploymentProviderAwsAlb2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderUnion2$inboundSchema: z.ZodType<DeploymentProviderUnion2, unknown>;
+export declare function deploymentProviderUnion2FromJSON(jsonString: string): SafeParseResult<DeploymentProviderUnion2, SDKValidationError>;
+/** @internal */
+export declare const DeploymentRouteGateway1$inboundSchema: z.ZodType<DeploymentRouteGateway1, unknown>;
+export declare function deploymentRouteGateway1FromJSON(jsonString: string): SafeParseResult<DeploymentRouteGateway1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderAzureApplicationGatewayForContainersEnum1$inboundSchema: z.ZodEnum<typeof DeploymentProviderAzureApplicationGatewayForContainersEnum1>;
+/** @internal */
+export declare const DeploymentProviderAzureApplicationGatewayForContainers1$inboundSchema: z.ZodType<DeploymentProviderAzureApplicationGatewayForContainers1, unknown>;
+export declare function deploymentProviderAzureApplicationGatewayForContainers1FromJSON(jsonString: string): SafeParseResult<DeploymentProviderAzureApplicationGatewayForContainers1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderGkeGatewayEnum1$inboundSchema: z.ZodEnum<typeof DeploymentProviderGkeGatewayEnum1>;
+/** @internal */
+export declare const DeploymentProviderGkeGateway1$inboundSchema: z.ZodType<DeploymentProviderGkeGateway1, unknown>;
+export declare function deploymentProviderGkeGateway1FromJSON(jsonString: string): SafeParseResult<DeploymentProviderGkeGateway1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderAwsAlbEnum1$inboundSchema: z.ZodEnum<typeof DeploymentProviderAwsAlbEnum1>;
+/** @internal */
+export declare const DeploymentProviderAwsAlb1$inboundSchema: z.ZodType<DeploymentProviderAwsAlb1, unknown>;
+export declare function deploymentProviderAwsAlb1FromJSON(jsonString: string): SafeParseResult<DeploymentProviderAwsAlb1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentProviderUnion1$inboundSchema: z.ZodType<DeploymentProviderUnion1, unknown>;
+export declare function deploymentProviderUnion1FromJSON(jsonString: string): SafeParseResult<DeploymentProviderUnion1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentRouteIngress1$inboundSchema: z.ZodType<DeploymentRouteIngress1, unknown>;
+export declare function deploymentRouteIngress1FromJSON(jsonString: string): SafeParseResult<DeploymentRouteIngress1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentRouteUnion1$inboundSchema: z.ZodType<DeploymentRouteUnion1, unknown>;
+export declare function deploymentRouteUnion1FromJSON(jsonString: string): SafeParseResult<DeploymentRouteUnion1, SDKValidationError>;
+/** @internal */
+export declare const DeploymentExposureGenerated$inboundSchema: z.ZodType<DeploymentExposureGenerated, unknown>;
+export declare function deploymentExposureGeneratedFromJSON(jsonString: string): SafeParseResult<DeploymentExposureGenerated, SDKValidationError>;
+/** @internal */
+export declare const DeploymentModeDisabled$inboundSchema: z.ZodEnum<typeof DeploymentModeDisabled>;
+/** @internal */
+export declare const DeploymentExposureDisabled$inboundSchema: z.ZodType<DeploymentExposureDisabled, unknown>;
+export declare function deploymentExposureDisabledFromJSON(jsonString: string): SafeParseResult<DeploymentExposureDisabled, SDKValidationError>;
+/** @internal */
+export declare const DeploymentExposureUnion$inboundSchema: z.ZodType<DeploymentExposureUnion, unknown>;
+export declare function deploymentExposureUnionFromJSON(jsonString: string): SafeParseResult<DeploymentExposureUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentKubernetes$inboundSchema: z.ZodType<DeploymentKubernetes, unknown>;
+export declare function deploymentKubernetesFromJSON(jsonString: string): SafeParseResult<DeploymentKubernetes, SDKValidationError>;
+/** @internal */
+export declare const DeploymentKubernetesUnion$inboundSchema: z.ZodType<DeploymentKubernetesUnion, unknown>;
+export declare function deploymentKubernetesUnionFromJSON(jsonString: string): SafeParseResult<DeploymentKubernetesUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentTypeByoVnetAzure$inboundSchema: z.ZodEnum<typeof DeploymentTypeByoVnetAzure>;
+/** @internal */
+export declare const DeploymentNetworkByoVnetAzure$inboundSchema: z.ZodType<DeploymentNetworkByoVnetAzure, unknown>;
+export declare function deploymentNetworkByoVnetAzureFromJSON(jsonString: string): SafeParseResult<DeploymentNetworkByoVnetAzure, SDKValidationError>;
+/** @internal */
+export declare const DeploymentTypeByoVpcGcp$inboundSchema: z.ZodEnum<typeof DeploymentTypeByoVpcGcp>;
+/** @internal */
+export declare const DeploymentNetworkByoVpcGcp$inboundSchema: z.ZodType<DeploymentNetworkByoVpcGcp, unknown>;
+export declare function deploymentNetworkByoVpcGcpFromJSON(jsonString: string): SafeParseResult<DeploymentNetworkByoVpcGcp, SDKValidationError>;
+/** @internal */
+export declare const DeploymentTypeByoVpcAws$inboundSchema: z.ZodEnum<typeof DeploymentTypeByoVpcAws>;
+/** @internal */
+export declare const DeploymentNetworkByoVpcAws$inboundSchema: z.ZodType<DeploymentNetworkByoVpcAws, unknown>;
+export declare function deploymentNetworkByoVpcAwsFromJSON(jsonString: string): SafeParseResult<DeploymentNetworkByoVpcAws, SDKValidationError>;
+/** @internal */
+export declare const DeploymentTypeCreate$inboundSchema: z.ZodEnum<typeof DeploymentTypeCreate>;
+/** @internal */
+export declare const DeploymentNetworkCreate$inboundSchema: z.ZodType<DeploymentNetworkCreate, unknown>;
+export declare function deploymentNetworkCreateFromJSON(jsonString: string): SafeParseResult<DeploymentNetworkCreate, SDKValidationError>;
+/** @internal */
+export declare const DeploymentTypeUseDefault$inboundSchema: z.ZodEnum<typeof DeploymentTypeUseDefault>;
+/** @internal */
+export declare const DeploymentNetworkUseDefault$inboundSchema: z.ZodType<DeploymentNetworkUseDefault, unknown>;
+export declare function deploymentNetworkUseDefaultFromJSON(jsonString: string): SafeParseResult<DeploymentNetworkUseDefault, SDKValidationError>;
+/** @internal */
+export declare const DeploymentNetworkUnion$inboundSchema: z.ZodType<DeploymentNetworkUnion, unknown>;
+export declare function deploymentNetworkUnionFromJSON(jsonString: string): SafeParseResult<DeploymentNetworkUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentSetupManagement$inboundSchema: z.ZodEnum<typeof DeploymentSetupManagement>;
+/** @internal */
+export declare const DeploymentTelemetry$inboundSchema: z.ZodEnum<typeof DeploymentTelemetry>;
+/** @internal */
+export declare const DeploymentUpdates$inboundSchema: z.ZodEnum<typeof DeploymentUpdates>;
+/** @internal */
+export declare const DeploymentStackSettings$inboundSchema: z.ZodType<DeploymentStackSettings, unknown>;
+export declare function deploymentStackSettingsFromJSON(jsonString: string): SafeParseResult<DeploymentStackSettings, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStackStatePlatform$inboundSchema: z.ZodEnum<typeof DeploymentStackStatePlatform>;
+/** @internal */
+export declare const DeploymentStackStateConfig$inboundSchema: z.ZodType<DeploymentStackStateConfig, unknown>;
+export declare function deploymentStackStateConfigFromJSON(jsonString: string): SafeParseResult<DeploymentStackStateConfig, SDKValidationError>;
+/** @internal */
+export declare const DeploymentControllerPlatformEnum$inboundSchema: z.ZodEnum<typeof DeploymentControllerPlatformEnum>;
+/** @internal */
+export declare const DeploymentControllerPlatformUnion$inboundSchema: z.ZodType<DeploymentControllerPlatformUnion, unknown>;
+export declare function deploymentControllerPlatformUnionFromJSON(jsonString: string): SafeParseResult<DeploymentControllerPlatformUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStackStateDependency$inboundSchema: z.ZodType<DeploymentStackStateDependency, unknown>;
+export declare function deploymentStackStateDependencyFromJSON(jsonString: string): SafeParseResult<DeploymentStackStateDependency, SDKValidationError>;
+/** @internal */
+export declare const DeploymentErrorStackState$inboundSchema: z.ZodType<DeploymentErrorStackState, unknown>;
+export declare function deploymentErrorStackStateFromJSON(jsonString: string): SafeParseResult<DeploymentErrorStackState, SDKValidationError>;
+/** @internal */
+export declare const DeploymentErrorUnion$inboundSchema: z.ZodType<DeploymentErrorUnion, unknown>;
+export declare function deploymentErrorUnionFromJSON(jsonString: string): SafeParseResult<DeploymentErrorUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentLifecycleStackStateEnum$inboundSchema: z.ZodEnum<typeof DeploymentLifecycleStackStateEnum>;
+/** @internal */
+export declare const DeploymentLifecycleUnion$inboundSchema: z.ZodType<DeploymentLifecycleUnion, unknown>;
+export declare function deploymentLifecycleUnionFromJSON(jsonString: string): SafeParseResult<DeploymentLifecycleUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentOutputs$inboundSchema: z.ZodType<DeploymentOutputs, unknown>;
+export declare function deploymentOutputsFromJSON(jsonString: string): SafeParseResult<DeploymentOutputs, SDKValidationError>;
+/** @internal */
+export declare const DeploymentOutputsUnion$inboundSchema: z.ZodType<DeploymentOutputsUnion, unknown>;
+export declare function deploymentOutputsUnionFromJSON(jsonString: string): SafeParseResult<DeploymentOutputsUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPreviousConfig$inboundSchema: z.ZodType<DeploymentPreviousConfig, unknown>;
+export declare function deploymentPreviousConfigFromJSON(jsonString: string): SafeParseResult<DeploymentPreviousConfig, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPreviousConfigUnion$inboundSchema: z.ZodType<DeploymentPreviousConfigUnion, unknown>;
+export declare function deploymentPreviousConfigUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreviousConfigUnion, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStackStateStatus$inboundSchema: z.ZodEnum<typeof DeploymentStackStateStatus>;
+/** @internal */
+export declare const DeploymentStackStateResources$inboundSchema: z.ZodType<DeploymentStackStateResources, unknown>;
+export declare function deploymentStackStateResourcesFromJSON(jsonString: string): SafeParseResult<DeploymentStackStateResources, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStackState$inboundSchema: z.ZodType<DeploymentStackState, unknown>;
+export declare function deploymentStackStateFromJSON(jsonString: string): SafeParseResult<DeploymentStackState, SDKValidationError>;
+/** @internal */
+export declare const DeploymentStore$inboundSchema: z.ZodEnum<typeof DeploymentStore>;
+/** @internal */
+export declare const DeploymentLocation$inboundSchema: z.ZodType<DeploymentLocation, unknown>;
+export declare function deploymentLocationFromJSON(jsonString: string): SafeParseResult<DeploymentLocation, SDKValidationError>;
+/** @internal */
+export declare const DeploymentRuntimeMetadataStatus$inboundSchema: z.ZodEnum<typeof DeploymentRuntimeMetadataStatus>;
+/** @internal */
+export declare const DeploymentDeployerSecret$inboundSchema: z.ZodType<DeploymentDeployerSecret, unknown>;
+export declare function deploymentDeployerSecretFromJSON(jsonString: string): SafeParseResult<DeploymentDeployerSecret, SDKValidationError>;
+/** @internal */
+export declare const DeploymentInitialSetupAuthority$inboundSchema: z.ZodEnum<typeof DeploymentInitialSetupAuthority>;
+/** @internal */
+export declare const DeploymentPendingPreparedStackTypeStringList$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackTypeStringList>;
+/** @internal */
+export declare const DeploymentPendingPreparedStackDefaultStringList$inboundSchema: z.ZodType<DeploymentPendingPreparedStackDefaultStringList, unknown>;
+export declare function deploymentPendingPreparedStackDefaultStringListFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackDefaultStringList, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPendingPreparedStackTypeBoolean$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackTypeBoolean>;
+/** @internal */
+export declare const DeploymentPendingPreparedStackDefaultBoolean$inboundSchema: z.ZodType<DeploymentPendingPreparedStackDefaultBoolean, unknown>;
+export declare function deploymentPendingPreparedStackDefaultBooleanFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackDefaultBoolean, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPendingPreparedStackTypeNumber$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackTypeNumber>;
+/** @internal */
+export declare const DeploymentPendingPreparedStackDefaultNumber$inboundSchema: z.ZodType<DeploymentPendingPreparedStackDefaultNumber, unknown>;
+export declare function deploymentPendingPreparedStackDefaultNumberFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackDefaultNumber, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPendingPreparedStackTypeString$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackTypeString>;
+/** @internal */
+export declare const DeploymentPendingPreparedStackDefaultString$inboundSchema: z.ZodType<DeploymentPendingPreparedStackDefaultString, unknown>;
+export declare function deploymentPendingPreparedStackDefaultStringFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackDefaultString, SDKValidationError>;
+/** @internal */
+export declare const DeploymentPendingPreparedStackDefaultUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackDefaultUnion, unknown>;
+export declare function deploymentPendingPreparedStackDefaultUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackDefaultUnion, SDKValidationError>;
+//# sourceMappingURL=deploymentpendingpreparedstackdefaultunion.d.ts.map