import * as z from "zod/v4";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import { AiAvailabilityObservation } from "./aiavailabilityobservation.js";
import { DeploymentInfoSetupConfig } from "./deploymentinfosetupconfig.js";
import { DeploymentPortalAppearance } from "./deploymentportalappearance.js";
import { SDKValidationError } from "./errors/sdkvalidationerror.js";
import { SetupItemStatus } from "./setupitemstatus.js";
import { SupportedCloudRegions } from "./supportedcloudregions.js";
/**
 * Represents the target cloud platform.
 */
export declare const SetupUpdatePlatform: {
    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 SetupUpdatePlatform = ClosedEnum<typeof SetupUpdatePlatform>;
export declare const DeploymentInfoSetupMethod: {
    readonly Cloudformation: "cloudformation";
    readonly GoogleOauth: "google-oauth";
    readonly Terraform: "terraform";
    readonly Helm: "helm";
    readonly Cli: "cli";
    readonly Manual: "manual";
};
export type DeploymentInfoSetupMethod = ClosedEnum<typeof DeploymentInfoSetupMethod>;
/**
 * Failure-domain policy selected for a compute pool.
 */
export type DeploymentInfoFailureDomains2 = {
    /**
     * 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 DeploymentInfoFailureDomainsUnion2 = DeploymentInfoFailureDomains2 | any;
export type DeploymentInfoPoolsAutoscale = {
    failureDomains?: DeploymentInfoFailureDomains2 | any | 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 DeploymentInfoFailureDomains1 = {
    /**
     * 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 DeploymentInfoFailureDomainsUnion1 = DeploymentInfoFailureDomains1 | any;
export type DeploymentInfoPoolsFixed = {
    failureDomains?: DeploymentInfoFailureDomains1 | any | 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 DeploymentInfoPoolsUnion = DeploymentInfoPoolsFixed | DeploymentInfoPoolsAutoscale;
/**
 * 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 DeploymentInfoCompute = {
    /**
     * Selected compute choices keyed by pool ID.
     */
    pools?: {
        [k: string]: DeploymentInfoPoolsFixed | DeploymentInfoPoolsAutoscale;
    } | undefined;
};
export type DeploymentInfoComputeUnion = DeploymentInfoCompute | any;
/**
 * Deployment model: how updates are delivered to the remote environment.
 */
export declare const DeploymentInfoDeploymentModel: {
    readonly Push: "push";
    readonly Pull: "pull";
};
/**
 * Deployment model: how updates are delivered to the remote environment.
 */
export type DeploymentInfoDeploymentModel = ClosedEnum<typeof DeploymentInfoDeploymentModel>;
export type DeploymentInfoAws = {
    certificateArn: string;
};
export type DeploymentInfoAwsUnion = DeploymentInfoAws | any;
export type DeploymentInfoAzure = {
    keyVaultCertificateId: string;
    keyVaultResourceId?: string | null | undefined;
};
export type DeploymentInfoAzureUnion = DeploymentInfoAzure | any;
export type DeploymentInfoGcp = {
    certificateName: string;
};
export type DeploymentInfoGcpUnion = DeploymentInfoGcp | any;
/**
 * Namespace-scoped Kubernetes TLS Secret reference.
 */
export type DeploymentInfoTlsSecretRef = {
    /**
     * Secret namespace. Defaults to the release namespace when omitted.
     */
    namespace?: string | null | undefined;
    /**
     * Secret name.
     */
    secretName: string;
};
export type DeploymentInfoDomainsKubernetes = {
    /**
     * Namespace-scoped Kubernetes TLS Secret reference.
     */
    tlsSecretRef: DeploymentInfoTlsSecretRef;
};
export type DeploymentInfoDomainsKubernetesUnion = DeploymentInfoDomainsKubernetes | any;
/**
 * Platform-specific certificate references for custom domains.
 */
export type DeploymentInfoDomainsCertificate = {
    aws?: DeploymentInfoAws | any | null | undefined;
    azure?: DeploymentInfoAzure | any | null | undefined;
    gcp?: DeploymentInfoGcp | any | null | undefined;
    kubernetes?: DeploymentInfoDomainsKubernetes | any | null | undefined;
};
/**
 * Custom domain configuration for a single resource.
 */
export type DeploymentInfoCustomDomains = {
    /**
     * Platform-specific certificate references for custom domains.
     */
    certificate: DeploymentInfoDomainsCertificate;
    /**
     * Fully qualified domain name to use.
     */
    domain: string;
};
export declare const SetupUpdateModeLoadBalancer: {
    readonly LoadBalancer: "loadBalancer";
};
export type SetupUpdateModeLoadBalancer = ClosedEnum<typeof SetupUpdateModeLoadBalancer>;
export type DeploymentInfoPublicEndpointTargetLoadBalancer = {
    /**
     * DNS name or URL for the external load balancer.
     */
    cnameTarget: string;
    mode: SetupUpdateModeLoadBalancer;
};
export declare const SetupUpdateModeMachineAddresses: {
    readonly MachineAddresses: "machineAddresses";
};
export type SetupUpdateModeMachineAddresses = ClosedEnum<typeof SetupUpdateModeMachineAddresses>;
export type DeploymentInfoPublicEndpointTargetMachineAddresses = {
    mode: SetupUpdateModeMachineAddresses;
};
export type DeploymentInfoPublicEndpointTargetUnion = DeploymentInfoPublicEndpointTargetLoadBalancer | DeploymentInfoPublicEndpointTargetMachineAddresses | any;
/**
 * 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 DeploymentInfoDomains = {
    /**
     * Custom domain configuration per resource ID.
     */
    customDomains?: {
        [k: string]: DeploymentInfoCustomDomains;
    } | null | undefined;
    publicEndpointTarget?: DeploymentInfoPublicEndpointTargetLoadBalancer | DeploymentInfoPublicEndpointTargetMachineAddresses | any | null | undefined;
};
export type DeploymentInfoDomainsUnion = DeploymentInfoDomains | any;
/**
 * External bindings for pre-existing infrastructure.
 *
 * @remarks
 * Allows using existing resources (MinIO, Redis, shared Container Apps
 * Environment, etc.) instead of having Alien provision them.
 * Required for Kubernetes platform, optional for cloud platforms.
 */
export type DeploymentInfoExternalBindings = {};
/**
 * How heartbeat health checks are handled.
 */
export declare const DeploymentInfoHeartbeats: {
    readonly Off: "off";
    readonly On: "on";
};
/**
 * How heartbeat health checks are handled.
 */
export type DeploymentInfoHeartbeats = ClosedEnum<typeof DeploymentInfoHeartbeats>;
/**
 * Optional provider-specific identity for a cloud-backed Kubernetes cluster.
 */
export type DeploymentInfoCloud = {
    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 DeploymentInfoCloudUnion = DeploymentInfoCloud | any;
/**
 * Ownership model for the Kubernetes cluster.
 */
export declare const DeploymentInfoOwnership: {
    readonly Managed: "managed";
    readonly Existing: "existing";
    readonly External: "external";
};
/**
 * Ownership model for the Kubernetes cluster.
 */
export type DeploymentInfoOwnership = ClosedEnum<typeof DeploymentInfoOwnership>;
/**
 * Kubernetes cluster setup settings.
 */
export type DeploymentInfoCluster = {
    cloud?: DeploymentInfoCloud | any | null | undefined;
    /**
     * Namespace where the Alien chart and application resources run.
     */
    namespace?: string | null | undefined;
    /**
     * Ownership model for the Kubernetes cluster.
     */
    ownership: DeploymentInfoOwnership;
};
export type DeploymentInfoClusterUnion = DeploymentInfoCluster | any;
export type DeploymentInfoCertificateNone2 = {
    mode: "none";
};
export type DeploymentInfoCertificateManagedTLSSecret2 = {
    mode: "managedTlsSecret";
    /**
     * Secret name template. Runtime may substitute resource/deployment tokens.
     */
    secretNameTemplate: string;
};
export type DeploymentInfoCertificateAwsAcmArn2 = {
    /**
     * Existing ACM certificate ARN.
     */
    certificateArn: string;
    mode: "awsAcmArn";
};
export type DeploymentInfoCertificateManagedAcmImport2 = {
    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 DeploymentInfoCertificateTLSSecretRef2 = {
    /**
     * 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 DeploymentInfoCertificateUnion2 = DeploymentInfoCertificateTLSSecretRef2 | DeploymentInfoCertificateManagedAcmImport2 | DeploymentInfoCertificateAwsAcmArn2 | DeploymentInfoCertificateManagedTLSSecret2 | DeploymentInfoCertificateNone2;
export declare const SetupUpdateModeCustom: {
    readonly Custom: "custom";
};
export type SetupUpdateModeCustom = ClosedEnum<typeof SetupUpdateModeCustom>;
export declare const SetupUpdateProviderAzureApplicationGatewayForContainersEnum4: {
    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
};
export type SetupUpdateProviderAzureApplicationGatewayForContainersEnum4 = ClosedEnum<typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum4>;
export type ProviderSetupUpdateAzureApplicationGatewayForContainers4 = {
    /**
     * 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: SetupUpdateProviderAzureApplicationGatewayForContainersEnum4;
};
export declare const SetupUpdateProviderGkeGatewayEnum4: {
    readonly GkeGateway: "gkeGateway";
};
export type SetupUpdateProviderGkeGatewayEnum4 = ClosedEnum<typeof SetupUpdateProviderGkeGatewayEnum4>;
export type ProviderSetupUpdateGkeGateway4 = {
    provider: SetupUpdateProviderGkeGatewayEnum4;
    /**
     * Optional static address name for the Gateway frontend.
     */
    staticAddressName?: string | null | undefined;
};
export declare const SetupUpdateProviderAwsAlbEnum4: {
    readonly AwsAlb: "awsAlb";
};
export type SetupUpdateProviderAwsAlbEnum4 = ClosedEnum<typeof SetupUpdateProviderAwsAlbEnum4>;
export type ProviderSetupUpdateAwsAlb4 = {
    /**
     * Optional ALB IP address type, such as `dualstack`.
     */
    ipAddressType?: string | null | undefined;
    provider: SetupUpdateProviderAwsAlbEnum4;
    /**
     * 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 SetupUpdateProviderUnion4 = ProviderSetupUpdateAwsAlb4 | ProviderSetupUpdateAzureApplicationGatewayForContainers4 | ProviderSetupUpdateGkeGateway4 | any;
/**
 * Shared Gateway API route profile values.
 */
export type DeploymentInfoRouteGateway2 = {
    /**
     * 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?: ProviderSetupUpdateAwsAlb4 | ProviderSetupUpdateAzureApplicationGatewayForContainers4 | ProviderSetupUpdateGkeGateway4 | any | null | undefined;
    routeApi: "gateway";
};
export declare const SetupUpdateProviderAzureApplicationGatewayForContainersEnum3: {
    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
};
export type SetupUpdateProviderAzureApplicationGatewayForContainersEnum3 = ClosedEnum<typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum3>;
export type ProviderSetupUpdateAzureApplicationGatewayForContainers3 = {
    /**
     * 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: SetupUpdateProviderAzureApplicationGatewayForContainersEnum3;
};
export declare const SetupUpdateProviderGkeGatewayEnum3: {
    readonly GkeGateway: "gkeGateway";
};
export type SetupUpdateProviderGkeGatewayEnum3 = ClosedEnum<typeof SetupUpdateProviderGkeGatewayEnum3>;
export type ProviderSetupUpdateGkeGateway3 = {
    provider: SetupUpdateProviderGkeGatewayEnum3;
    /**
     * Optional static address name for the Gateway frontend.
     */
    staticAddressName?: string | null | undefined;
};
export declare const SetupUpdateProviderAwsAlbEnum3: {
    readonly AwsAlb: "awsAlb";
};
export type SetupUpdateProviderAwsAlbEnum3 = ClosedEnum<typeof SetupUpdateProviderAwsAlbEnum3>;
export type ProviderSetupUpdateAwsAlb3 = {
    /**
     * Optional ALB IP address type, such as `dualstack`.
     */
    ipAddressType?: string | null | undefined;
    provider: SetupUpdateProviderAwsAlbEnum3;
    /**
     * 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 SetupUpdateProviderUnion3 = ProviderSetupUpdateAwsAlb3 | ProviderSetupUpdateAzureApplicationGatewayForContainers3 | ProviderSetupUpdateGkeGateway3 | any;
/**
 * Shared Ingress route profile values.
 */
export type DeploymentInfoRouteIngress2 = {
    /**
     * 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?: ProviderSetupUpdateAwsAlb3 | ProviderSetupUpdateAzureApplicationGatewayForContainers3 | ProviderSetupUpdateGkeGateway3 | any | null | undefined;
    routeApi: "ingress";
};
/**
 * Kubernetes route API selected for public endpoints.
 */
export type DeploymentInfoRouteUnion2 = DeploymentInfoRouteIngress2 | DeploymentInfoRouteGateway2;
export type DeploymentInfoExposureCustom = {
    /**
     * Certificate publication or reference mode for Kubernetes public endpoints.
     */
    certificate: DeploymentInfoCertificateTLSSecretRef2 | DeploymentInfoCertificateManagedAcmImport2 | DeploymentInfoCertificateAwsAcmArn2 | DeploymentInfoCertificateManagedTLSSecret2 | DeploymentInfoCertificateNone2;
    /**
     * Hostname routed by the Kubernetes public endpoint.
     */
    domain: string;
    mode: SetupUpdateModeCustom;
    /**
     * Kubernetes route API selected for public endpoints.
     */
    route: DeploymentInfoRouteIngress2 | DeploymentInfoRouteGateway2;
};
export type DeploymentInfoCertificateNone1 = {
    mode: "none";
};
export type DeploymentInfoCertificateManagedTLSSecret1 = {
    mode: "managedTlsSecret";
    /**
     * Secret name template. Runtime may substitute resource/deployment tokens.
     */
    secretNameTemplate: string;
};
export type DeploymentInfoCertificateAwsAcmArn1 = {
    /**
     * Existing ACM certificate ARN.
     */
    certificateArn: string;
    mode: "awsAcmArn";
};
export type DeploymentInfoCertificateManagedAcmImport1 = {
    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 DeploymentInfoCertificateTLSSecretRef1 = {
    /**
     * 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 DeploymentInfoCertificateUnion1 = DeploymentInfoCertificateTLSSecretRef1 | DeploymentInfoCertificateManagedAcmImport1 | DeploymentInfoCertificateAwsAcmArn1 | DeploymentInfoCertificateManagedTLSSecret1 | DeploymentInfoCertificateNone1;
export declare const SetupUpdateModeGenerated: {
    readonly Generated: "generated";
};
export type SetupUpdateModeGenerated = ClosedEnum<typeof SetupUpdateModeGenerated>;
export declare const SetupUpdateProviderAzureApplicationGatewayForContainersEnum2: {
    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
};
export type SetupUpdateProviderAzureApplicationGatewayForContainersEnum2 = ClosedEnum<typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum2>;
export type ProviderSetupUpdateAzureApplicationGatewayForContainers2 = {
    /**
     * 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: SetupUpdateProviderAzureApplicationGatewayForContainersEnum2;
};
export declare const SetupUpdateProviderGkeGatewayEnum2: {
    readonly GkeGateway: "gkeGateway";
};
export type SetupUpdateProviderGkeGatewayEnum2 = ClosedEnum<typeof SetupUpdateProviderGkeGatewayEnum2>;
export type ProviderSetupUpdateGkeGateway2 = {
    provider: SetupUpdateProviderGkeGatewayEnum2;
    /**
     * Optional static address name for the Gateway frontend.
     */
    staticAddressName?: string | null | undefined;
};
export declare const SetupUpdateProviderAwsAlbEnum2: {
    readonly AwsAlb: "awsAlb";
};
export type SetupUpdateProviderAwsAlbEnum2 = ClosedEnum<typeof SetupUpdateProviderAwsAlbEnum2>;
export type ProviderSetupUpdateAwsAlb2 = {
    /**
     * Optional ALB IP address type, such as `dualstack`.
     */
    ipAddressType?: string | null | undefined;
    provider: SetupUpdateProviderAwsAlbEnum2;
    /**
     * 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 SetupUpdateProviderUnion2 = ProviderSetupUpdateAwsAlb2 | ProviderSetupUpdateAzureApplicationGatewayForContainers2 | ProviderSetupUpdateGkeGateway2 | any;
/**
 * Shared Gateway API route profile values.
 */
export type DeploymentInfoRouteGateway1 = {
    /**
     * 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?: ProviderSetupUpdateAwsAlb2 | ProviderSetupUpdateAzureApplicationGatewayForContainers2 | ProviderSetupUpdateGkeGateway2 | any | null | undefined;
    routeApi: "gateway";
};
export declare const SetupUpdateProviderAzureApplicationGatewayForContainersEnum1: {
    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
};
export type SetupUpdateProviderAzureApplicationGatewayForContainersEnum1 = ClosedEnum<typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum1>;
export type ProviderSetupUpdateAzureApplicationGatewayForContainers1 = {
    /**
     * 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: SetupUpdateProviderAzureApplicationGatewayForContainersEnum1;
};
export declare const SetupUpdateProviderGkeGatewayEnum1: {
    readonly GkeGateway: "gkeGateway";
};
export type SetupUpdateProviderGkeGatewayEnum1 = ClosedEnum<typeof SetupUpdateProviderGkeGatewayEnum1>;
export type ProviderSetupUpdateGkeGateway1 = {
    provider: SetupUpdateProviderGkeGatewayEnum1;
    /**
     * Optional static address name for the Gateway frontend.
     */
    staticAddressName?: string | null | undefined;
};
export declare const SetupUpdateProviderAwsAlbEnum1: {
    readonly AwsAlb: "awsAlb";
};
export type SetupUpdateProviderAwsAlbEnum1 = ClosedEnum<typeof SetupUpdateProviderAwsAlbEnum1>;
export type ProviderSetupUpdateAwsAlb1 = {
    /**
     * Optional ALB IP address type, such as `dualstack`.
     */
    ipAddressType?: string | null | undefined;
    provider: SetupUpdateProviderAwsAlbEnum1;
    /**
     * 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 SetupUpdateProviderUnion1 = ProviderSetupUpdateAwsAlb1 | ProviderSetupUpdateAzureApplicationGatewayForContainers1 | ProviderSetupUpdateGkeGateway1 | any;
/**
 * Shared Ingress route profile values.
 */
export type DeploymentInfoRouteIngress1 = {
    /**
     * 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?: ProviderSetupUpdateAwsAlb1 | ProviderSetupUpdateAzureApplicationGatewayForContainers1 | ProviderSetupUpdateGkeGateway1 | any | null | undefined;
    routeApi: "ingress";
};
/**
 * Kubernetes route API selected for public endpoints.
 */
export type DeploymentInfoRouteUnion1 = DeploymentInfoRouteIngress1 | DeploymentInfoRouteGateway1;
export type DeploymentInfoExposureGenerated = {
    /**
     * Certificate publication or reference mode for Kubernetes public endpoints.
     */
    certificate: DeploymentInfoCertificateTLSSecretRef1 | DeploymentInfoCertificateManagedAcmImport1 | DeploymentInfoCertificateAwsAcmArn1 | DeploymentInfoCertificateManagedTLSSecret1 | DeploymentInfoCertificateNone1;
    mode: SetupUpdateModeGenerated;
    /**
     * Kubernetes route API selected for public endpoints.
     */
    route: DeploymentInfoRouteIngress1 | DeploymentInfoRouteGateway1;
};
export declare const SetupUpdateModeDisabled: {
    readonly Disabled: "disabled";
};
export type SetupUpdateModeDisabled = ClosedEnum<typeof SetupUpdateModeDisabled>;
export type DeploymentInfoExposureDisabled = {
    mode: SetupUpdateModeDisabled;
};
export type DeploymentInfoExposureUnion = DeploymentInfoExposureCustom | DeploymentInfoExposureGenerated | DeploymentInfoExposureDisabled | any;
/**
 * 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 DeploymentInfoKubernetes = {
    cluster?: DeploymentInfoCluster | any | null | undefined;
    exposure?: DeploymentInfoExposureCustom | DeploymentInfoExposureGenerated | DeploymentInfoExposureDisabled | any | null | undefined;
};
export type DeploymentInfoKubernetesUnion = DeploymentInfoKubernetes | any;
export declare const DeploymentInfoTypeByoVnetAzure: {
    readonly ByoVnetAzure: "byo-vnet-azure";
};
export type DeploymentInfoTypeByoVnetAzure = ClosedEnum<typeof DeploymentInfoTypeByoVnetAzure>;
export type DeploymentInfoNetworkByoVnetAzure = {
    /**
     * 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: DeploymentInfoTypeByoVnetAzure;
    /**
     * The full resource ID of the existing VNet
     */
    vnetResourceId: string;
};
export declare const DeploymentInfoTypeByoVpcGcp: {
    readonly ByoVpcGcp: "byo-vpc-gcp";
};
export type DeploymentInfoTypeByoVpcGcp = ClosedEnum<typeof DeploymentInfoTypeByoVpcGcp>;
export type DeploymentInfoNetworkByoVpcGcp = {
    /**
     * 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: DeploymentInfoTypeByoVpcGcp;
};
export declare const DeploymentInfoTypeByoVpcAws: {
    readonly ByoVpcAws: "byo-vpc-aws";
};
export type DeploymentInfoTypeByoVpcAws = ClosedEnum<typeof DeploymentInfoTypeByoVpcAws>;
export type DeploymentInfoNetworkByoVpcAws = {
    /**
     * 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: DeploymentInfoTypeByoVpcAws;
    /**
     * The ID of the existing VPC
     */
    vpcId: string;
};
export declare const DeploymentInfoTypeCreate: {
    readonly Create: "create";
};
export type DeploymentInfoTypeCreate = ClosedEnum<typeof DeploymentInfoTypeCreate>;
export type DeploymentInfoNetworkCreate = {
    /**
     * 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: DeploymentInfoTypeCreate;
};
export declare const DeploymentInfoTypeUseDefault: {
    readonly UseDefault: "use-default";
};
export type DeploymentInfoTypeUseDefault = ClosedEnum<typeof DeploymentInfoTypeUseDefault>;
export type DeploymentInfoNetworkUseDefault = {
    type: DeploymentInfoTypeUseDefault;
};
export type DeploymentInfoNetworkUnion = DeploymentInfoNetworkByoVpcAws | DeploymentInfoNetworkByoVpcGcp | DeploymentInfoNetworkByoVnetAzure | DeploymentInfoNetworkUseDefault | DeploymentInfoNetworkCreate | any;
/**
 * How telemetry (logs, metrics, traces) is handled.
 */
export declare const DeploymentInfoTelemetry: {
    readonly Off: "off";
    readonly Auto: "auto";
    readonly ApprovalRequired: "approval-required";
};
/**
 * How telemetry (logs, metrics, traces) is handled.
 */
export type DeploymentInfoTelemetry = ClosedEnum<typeof DeploymentInfoTelemetry>;
/**
 * How updates are delivered to the deployment.
 */
export declare const DeploymentInfoUpdates: {
    readonly Auto: "auto";
    readonly ApprovalRequired: "approval-required";
};
/**
 * How updates are delivered to the deployment.
 */
export type DeploymentInfoUpdates = ClosedEnum<typeof DeploymentInfoUpdates>;
/**
 * User-customizable deployment settings specified at deploy time.
 *
 * @remarks
 *
 * These settings are provided by the customer via CloudFormation parameters,
 * Terraform attributes, CLI flags, or Helm values. They customize how the
 * deployment runs and what capabilities are enabled.
 *
 * **Key distinction**: StackSettings is user-customizable, while ManagementConfig
 * is platform-derived (from the Manager's ServiceAccount).
 */
export type DeploymentInfoStackSettings = {
    compute?: DeploymentInfoCompute | any | null | undefined;
    /**
     * Deployment model: how updates are delivered to the remote environment.
     */
    deploymentModel?: DeploymentInfoDeploymentModel | undefined;
    domains?: DeploymentInfoDomains | any | null | undefined;
    /**
     * External bindings for pre-existing infrastructure.
     *
     * @remarks
     * Allows using existing resources (MinIO, Redis, shared Container Apps
     * Environment, etc.) instead of having Alien provision them.
     * Required for Kubernetes platform, optional for cloud platforms.
     */
    externalBindings?: DeploymentInfoExternalBindings | null | undefined;
    /**
     * How heartbeat health checks are handled.
     */
    heartbeats?: DeploymentInfoHeartbeats | undefined;
    kubernetes?: DeploymentInfoKubernetes | any | null | undefined;
    network?: DeploymentInfoNetworkByoVpcAws | DeploymentInfoNetworkByoVpcGcp | DeploymentInfoNetworkByoVnetAzure | DeploymentInfoNetworkUseDefault | DeploymentInfoNetworkCreate | any | 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;
    /**
     * How telemetry (logs, metrics, traces) is handled.
     */
    telemetry?: DeploymentInfoTelemetry | undefined;
    /**
     * How updates are delivered to the deployment.
     */
    updates?: DeploymentInfoUpdates | undefined;
};
export type SetupUpdate = {
    deploymentId: string;
    updateOperationId: string;
    releaseId: string;
    name: string;
    /**
     * Represents the target cloud platform.
     */
    platform: SetupUpdatePlatform;
    setupMethod: DeploymentInfoSetupMethod | null;
    setupMetadata: {
        [k: string]: any | null;
    } | null;
    setupTarget: string | null;
    resourcePrefix: string | null;
    /**
     * User-customizable deployment settings specified at deploy time.
     *
     * @remarks
     *
     * These settings are provided by the customer via CloudFormation parameters,
     * Terraform attributes, CLI flags, or Helm values. They customize how the
     * deployment runs and what capabilities are enabled.
     *
     * **Key distinction**: StackSettings is user-customizable, while ManagementConfig
     * is platform-derived (from the Manager's ServiceAccount).
     */
    stackSettings: DeploymentInfoStackSettings;
};
/**
 * Type of token used to authenticate this request
 */
export declare const DeploymentInfoTokenType: {
    readonly Deployment: "deployment";
    readonly DeploymentGroup: "deployment-group";
};
/**
 * Type of token used to authenticate this request
 */
export type DeploymentInfoTokenType = ClosedEnum<typeof DeploymentInfoTokenType>;
/**
 * Represents the target cloud platform.
 */
export declare const DeploymentInfoDeploymentPlatform: {
    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 DeploymentInfoDeploymentPlatform = ClosedEnum<typeof DeploymentInfoDeploymentPlatform>;
/**
 * Deployment details (present when using a deployment-scoped token)
 */
export type DeploymentInfoDeployment = {
    name: string;
    /**
     * Represents the target cloud platform.
     */
    platform: DeploymentInfoDeploymentPlatform;
};
/**
 * Deployment group details (present when using a deployment-group token)
 */
export type DeploymentInfoDeploymentGroup = {
    /**
     * Unique identifier for the deployment group.
     */
    id: string;
    name: string;
    pinnedSubdomain: string | null;
};
export type DeploymentInfoWorkspace = {
    id: string;
    name: string;
    avatarUrl?: string | null | undefined;
};
export type Portal = {
    appearance: DeploymentPortalAppearance;
};
/**
 * Represents the target cloud platform.
 */
export declare const StackSummaryPlatform: {
    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 StackSummaryPlatform = ClosedEnum<typeof StackSummaryPlatform>;
export type ResourceCounts = {
    workers: number;
    containers: number;
    /**
     * Daemon resources that run on managed runtime machines
     */
    daemons?: number | undefined;
    /**
     * Resources that declare managed public HTTPS endpoint setup
     */
    publicHttpsEndpoints: number;
    /**
     * Storage, queue, KV, vault, database, or cache resources that Kubernetes needs Terraform to provision
     */
    externalInfra: number;
    total: number;
};
export type PublicEndpoint = {
    resourceId: string;
    endpointName: string;
    hostLabel: string;
    wildcardSubdomains: boolean;
};
export type StackSummary = {
    /**
     * Platforms supported by the active release
     */
    platforms: Array<StackSummaryPlatform>;
    /**
     * Whether the stack contains resources that require cloud VPC networking
     */
    requiresNetwork: boolean;
    /**
     * Whether this release offers one remotely accessible AI resource
     */
    customerModels: boolean;
    resourceCounts: ResourceCounts;
    /**
     * Public endpoints declared by the active release stack
     */
    publicEndpoints: Array<PublicEndpoint>;
};
/**
 * Parent domain for generated deployment URLs. Chosen public subdomains are only allowed when isSystem is false.
 */
export type GeneratedDomain = {
    domain: string;
    isSystem: boolean;
};
export type DeploymentInfoProject = {
    name: string;
    portal: Portal;
    stackSummary?: StackSummary | null | undefined;
    /**
     * Parent domain for generated deployment URLs. Chosen public subdomains are only allowed when isSystem is false.
     */
    generatedDomain?: GeneratedDomain | null | undefined;
};
/**
 * Status of a package build
 */
export declare const CliStatus: {
    readonly Pending: "pending";
    readonly Building: "building";
    readonly Ready: "ready";
    readonly Failed: "failed";
    readonly Canceled: "canceled";
};
/**
 * Status of a package build
 */
export type CliStatus = ClosedEnum<typeof CliStatus>;
/**
 * Information about a single binary artifact
 */
export type DeploymentInfoBinaries = {
    /**
     * SHA256 checksum
     */
    sha256: string;
    /**
     * File size in bytes
     */
    size: number;
    /**
     * Download URL for the binary
     */
    url: string;
};
/**
 * Source provenance for a generated CLI package.
 */
export type DeploymentInfoBuildInfo = {
    /**
     * Alien source commit used to build the source CLI and agent binaries.
     */
    alienSha: string;
    /**
     * Compute backend source revision used by optional package extensions, if applicable.
     */
    horizonSha: string;
    /**
     * Machine runtime release manifest embedded into the generated CLI.
     */
    machineBundleManifestUrl?: string | null | undefined;
    /**
     * Source revision used to build the package service and optional extensions.
     */
    platformSha: string;
    /**
     * SHA256 checksum of the source runtime helper binary shipped with the CLI package, when present.
     */
    sourceAgentBinarySha256?: string | null | undefined;
    /**
     * SHA256 checksum of the source deploy CLI binary before white-label config is appended.
     */
    sourceCliBinarySha256: string;
};
/**
 * Outputs from a CLI package build
 */
export type CliOutputs = {
    /**
     * Binary information for each target platform
     */
    binaries: {
        [k: string]: DeploymentInfoBinaries;
    };
    /**
     * Source provenance for a generated CLI package.
     */
    buildInfo: DeploymentInfoBuildInfo;
};
/**
 * Install script URLs for each OS
 */
export type InstallScripts = {
    windows: string;
    mac: string;
    linux: string;
};
export type DeploymentInfoCli = {
    /**
     * Status of a package build
     */
    status: CliStatus;
    /**
     * CLI command name to use in install instructions
     */
    commandName: string;
    version?: string | undefined;
    /**
     * Outputs from a CLI package build
     */
    outputs?: CliOutputs | undefined;
    error?: any | null | undefined;
    /**
     * Install script URLs for each OS
     */
    installScripts: InstallScripts;
};
/**
 * Status of a package build
 */
export declare const CloudformationStatus: {
    readonly Pending: "pending";
    readonly Building: "building";
    readonly Ready: "ready";
    readonly Failed: "failed";
    readonly Canceled: "canceled";
};
/**
 * Status of a package build
 */
export type CloudformationStatus = ClosedEnum<typeof CloudformationStatus>;
/**
 * Information about a single CloudFormation template package for one target.
 */
export type CloudformationTargets = {
    /**
     * AWS Console quick-launch URL
     */
    launchStackUrl: string;
    /**
     * SHA256 checksum of the template
     */
    sha256: string;
    /**
     * Template size in bytes
     */
    size: number;
    /**
     * S3 URL to the CloudFormation stack policy
     */
    stackPolicyUrl: string;
    /**
     * CloudFormation target (aws, eks)
     */
    target: string;
    /**
     * S3 URL to the CloudFormation template
     */
    templateUrl: string;
};
/**
 * Outputs from a CloudFormation package build.
 */
export type CloudformationOutputs = {
    /**
     * Template artifacts by CloudFormation target.
     */
    targets: {
        [k: string]: CloudformationTargets;
    };
};
export declare const CloudformationMode: {
    readonly Auto: "auto";
    readonly Outputs: "outputs";
};
export type CloudformationMode = ClosedEnum<typeof CloudformationMode>;
export type DeploymentInfoCloudformation = {
    /**
     * Status of a package build
     */
    status: CloudformationStatus;
    version?: string | undefined;
    /**
     * Outputs from a CloudFormation package build.
     */
    outputs?: CloudformationOutputs | undefined;
    error?: any | null | undefined;
    mode: CloudformationMode;
    /**
     * CloudFormation launch URL
     */
    launchUrl: string;
    outputsSchema?: any | null | undefined;
};
/**
 * Status of a package build
 */
export declare const TerraformStatus: {
    readonly Pending: "pending";
    readonly Building: "building";
    readonly Ready: "ready";
    readonly Failed: "failed";
    readonly Canceled: "canceled";
};
/**
 * Status of a package build
 */
export type TerraformStatus = ClosedEnum<typeof TerraformStatus>;
/**
 * Information about a single Terraform module package for one target.
 */
export type DeploymentInfoModules = {
    /**
     * Download URL for the module archive
     */
    downloadUrl: string;
    /**
     * Filename of the module archive
     */
    filename: string;
    /**
     * SHA256 checksum of the archive
     */
    shasum: string;
    /**
     * Size of the archive in bytes
     */
    size: number;
    /**
     * Terraform module source (hostname/namespace/name/provider, without scheme)
     */
    source: string;
    /**
     * Terraform module target (aws, gcp, azure, eks, gke, aks)
     */
    target: string;
    /**
     * Terraform input variables exposed by this module.
     */
    variables?: Array<string> | undefined;
};
/**
 * GPG public key for Terraform provider signature verification
 */
export type DeploymentInfoGpgPublicKey = {
    /**
     * ASCII-armored public key
     */
    asciiArmor: string;
    /**
     * GPG key ID
     */
    keyId: string;
};
/**
 * Information about a single Terraform provider package for a specific platform
 */
export type DeploymentInfoPlatforms = {
    /**
     * Download URL for the provider zip
     */
    downloadUrl: string;
    /**
     * Filename of the provider zip
     */
    filename: string;
    /**
     * SHA256 checksum of the zip file
     */
    shasum: string;
    /**
     * URL to the shasums signature file
     */
    shasumsSignatureUrl: string;
    /**
     * URL to the shasums file
     */
    shasumsUrl: string;
    /**
     * Size of the zip file in bytes
     */
    size: number;
};
/**
 * Terraform provider registry outputs.
 */
export type TerraformProvider = {
    /**
     * GPG public key for Terraform provider signature verification
     */
    gpgPublicKey: DeploymentInfoGpgPublicKey;
    /**
     * Provider packages for each target platform
     */
    platforms: {
        [k: string]: DeploymentInfoPlatforms;
    };
    /**
     * Terraform provider source (hostname/namespace/type, without scheme)
     */
    source: string;
};
/**
 * Outputs from a Terraform package build.
 */
export type TerraformOutputs = {
    /**
     * Module registry artifacts by Terraform target.
     */
    modules: {
        [k: string]: DeploymentInfoModules;
    };
    /**
     * Terraform provider registry outputs.
     */
    provider: TerraformProvider;
};
export type DeploymentInfoTerraform = {
    /**
     * Status of a package build
     */
    status: TerraformStatus;
    version?: string | undefined;
    /**
     * Outputs from a Terraform package build.
     */
    outputs?: TerraformOutputs | undefined;
    error?: any | null | undefined;
    /**
     * Terraform provider source (without https://)
     */
    providerSource: string;
    /**
     * Terraform module sources by target
     */
    moduleSources: {
        [k: string]: string;
    };
    moduleVersion?: string | undefined;
    /**
     * Manager URLs by Terraform target
     */
    managerUrls: {
        [k: string]: string;
    };
};
/**
 * Status of a package build
 */
export declare const HelmStatus: {
    readonly Pending: "pending";
    readonly Building: "building";
    readonly Ready: "ready";
    readonly Failed: "failed";
    readonly Canceled: "canceled";
};
/**
 * Status of a package build
 */
export type HelmStatus = ClosedEnum<typeof HelmStatus>;
/**
 * Outputs from a Helm chart package build
 */
export type HelmOutputs = {
    /**
     * OCI chart reference (e.g., "oci://public.ecr.aws/acme/charts/project-id")
     */
    chart: string;
    /**
     * Chart version (e.g., "1.2.3")
     */
    version: string;
};
export type DeploymentInfoHelm = {
    /**
     * Status of a package build
     */
    status: HelmStatus;
    version?: string | undefined;
    /**
     * Outputs from a Helm chart package build
     */
    outputs?: HelmOutputs | undefined;
    error?: any | null | undefined;
    /**
     * OCI chart reference
     */
    chartRef: string;
    managerFetchExample?: string | undefined;
    localImportExample?: string | undefined;
};
export type Packages = {
    /**
     * True if all enabled packages are ready for deployment
     */
    ready: boolean;
    cli?: DeploymentInfoCli | undefined;
    cloudformation?: DeploymentInfoCloudformation | undefined;
    terraform?: DeploymentInfoTerraform | undefined;
    helm?: DeploymentInfoHelm | undefined;
};
/**
 * Represents the target cloud platform.
 */
export declare const TargetsPlatform: {
    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 TargetsPlatform = ClosedEnum<typeof TargetsPlatform>;
export declare const TargetsPlatformKubernetes: {
    readonly Kubernetes: "kubernetes";
};
export type TargetsPlatformKubernetes = ClosedEnum<typeof TargetsPlatformKubernetes>;
export type DeploymentInfoManagementConfigKubernetes = {
    platform: TargetsPlatformKubernetes;
};
export declare const TargetsPlatformAzure: {
    readonly Azure: "azure";
};
export type TargetsPlatformAzure = ClosedEnum<typeof TargetsPlatformAzure>;
/**
 * Azure management configuration extracted from stack settings
 */
export type DeploymentInfoManagementConfigAzure = {
    /**
     * The managing Azure Tenant ID for cross-tenant access
     */
    managingTenantId: string;
    /**
     * OIDC issuer URL trusted by the target-side managed identity.
     */
    oidcIssuer: string;
    /**
     * OIDC subject claim trusted by the target-side managed identity.
     */
    oidcSubject: string;
    platform: TargetsPlatformAzure;
};
export declare const TargetsPlatformGcp: {
    readonly Gcp: "gcp";
};
export type TargetsPlatformGcp = ClosedEnum<typeof TargetsPlatformGcp>;
/**
 * GCP management configuration extracted from stack settings
 */
export type DeploymentInfoManagementConfigGcp = {
    /**
     * Service account email for management roles
     */
    serviceAccountEmail: string;
    platform: TargetsPlatformGcp;
};
export declare const TargetsPlatformAws: {
    readonly Aws: "aws";
};
export type TargetsPlatformAws = ClosedEnum<typeof TargetsPlatformAws>;
/**
 * AWS management configuration extracted from stack settings
 */
export type DeploymentInfoManagementConfigAws = {
    /**
     * The managing AWS IAM role ARN that can assume cross-account roles
     */
    managingRoleArn: string;
    platform: TargetsPlatformAws;
};
/**
 * Management configuration for different cloud platforms.
 *
 * @remarks
 *
 * Platform-derived configuration for cross-account/cross-tenant access.
 * This is NOT user-specified - it's derived from the Manager's ServiceAccount.
 */
export type DeploymentInfoManagementConfigUnion = DeploymentInfoManagementConfigAzure | DeploymentInfoManagementConfigAws | DeploymentInfoManagementConfigGcp | DeploymentInfoManagementConfigKubernetes | any;
export type InstallContextTargets = {
    /**
     * Represents the target cloud platform.
     */
    platform: TargetsPlatform;
    managerUrl: string;
    /**
     * Management configuration for different cloud platforms.
     *
     * @remarks
     *
     * Platform-derived configuration for cross-account/cross-tenant access.
     * This is NOT user-specified - it's derived from the Manager's ServiceAccount.
     */
    managementConfig?: DeploymentInfoManagementConfigAzure | DeploymentInfoManagementConfigAws | DeploymentInfoManagementConfigGcp | DeploymentInfoManagementConfigKubernetes | any | null | undefined;
    awsManagingAccountId?: string | undefined;
};
export type DeploymentInfoInstallContext = {
    /**
     * Deployment-session install context by Terraform/installer target
     */
    targets: {
        [k: string]: InstallContextTargets;
    };
};
export declare const ModelAvailabilitySourceStatus: {
    readonly Current: "current";
    readonly Stale: "stale";
    readonly Invalid: "invalid";
};
export type ModelAvailabilitySourceStatus = ClosedEnum<typeof ModelAvailabilitySourceStatus>;
export type ModelAvailabilitySource = {
    deploymentId: string;
    resourceId: string;
    observedAt: Date;
    status: ModelAvailabilitySourceStatus;
    availability?: AiAvailabilityObservation | undefined;
};
export declare const ReadinessStatus: {
    readonly Ready: "ready";
    readonly NotReady: "notReady";
    readonly Unknown: "unknown";
};
export type ReadinessStatus = ClosedEnum<typeof ReadinessStatus>;
export declare const CheckStatus: {
    readonly Passed: "passed";
    readonly Failed: "failed";
    readonly Warning: "warning";
    readonly Unknown: "unknown";
};
export type CheckStatus = ClosedEnum<typeof CheckStatus>;
export type Check = {
    code: string;
    status: CheckStatus;
    message: string;
    checkedAt: string;
};
export type Readiness = {
    status: ReadinessStatus;
    checks: Array<Check>;
};
export type DeploymentInfo = {
    setupUpdate?: SetupUpdate | undefined;
    /**
     * Type of token used to authenticate this request
     */
    tokenType: DeploymentInfoTokenType;
    /**
     * Deployment details (present when using a deployment-scoped token)
     */
    deployment?: DeploymentInfoDeployment | undefined;
    /**
     * Deployment group details (present when using a deployment-group token)
     */
    deploymentGroup?: DeploymentInfoDeploymentGroup | undefined;
    workspace: DeploymentInfoWorkspace;
    project: DeploymentInfoProject;
    packages: Packages;
    installContext: DeploymentInfoInstallContext;
    supportedRegions: SupportedCloudRegions;
    modelAvailabilitySources: Array<ModelAvailabilitySource>;
    setupItems?: Array<SetupItemStatus> | undefined;
    setupConfig?: DeploymentInfoSetupConfig | undefined;
    readiness?: Readiness | undefined;
};
/** @internal */
export declare const SetupUpdatePlatform$inboundSchema: z.ZodEnum<typeof SetupUpdatePlatform>;
/** @internal */
export declare const DeploymentInfoSetupMethod$inboundSchema: z.ZodEnum<typeof DeploymentInfoSetupMethod>;
/** @internal */
export declare const DeploymentInfoFailureDomains2$inboundSchema: z.ZodType<DeploymentInfoFailureDomains2, unknown>;
export declare function deploymentInfoFailureDomains2FromJSON(jsonString: string): SafeParseResult<DeploymentInfoFailureDomains2, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoFailureDomainsUnion2$inboundSchema: z.ZodType<DeploymentInfoFailureDomainsUnion2, unknown>;
export declare function deploymentInfoFailureDomainsUnion2FromJSON(jsonString: string): SafeParseResult<DeploymentInfoFailureDomainsUnion2, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoPoolsAutoscale$inboundSchema: z.ZodType<DeploymentInfoPoolsAutoscale, unknown>;
export declare function deploymentInfoPoolsAutoscaleFromJSON(jsonString: string): SafeParseResult<DeploymentInfoPoolsAutoscale, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoFailureDomains1$inboundSchema: z.ZodType<DeploymentInfoFailureDomains1, unknown>;
export declare function deploymentInfoFailureDomains1FromJSON(jsonString: string): SafeParseResult<DeploymentInfoFailureDomains1, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoFailureDomainsUnion1$inboundSchema: z.ZodType<DeploymentInfoFailureDomainsUnion1, unknown>;
export declare function deploymentInfoFailureDomainsUnion1FromJSON(jsonString: string): SafeParseResult<DeploymentInfoFailureDomainsUnion1, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoPoolsFixed$inboundSchema: z.ZodType<DeploymentInfoPoolsFixed, unknown>;
export declare function deploymentInfoPoolsFixedFromJSON(jsonString: string): SafeParseResult<DeploymentInfoPoolsFixed, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoPoolsUnion$inboundSchema: z.ZodType<DeploymentInfoPoolsUnion, unknown>;
export declare function deploymentInfoPoolsUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoPoolsUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCompute$inboundSchema: z.ZodType<DeploymentInfoCompute, unknown>;
export declare function deploymentInfoComputeFromJSON(jsonString: string): SafeParseResult<DeploymentInfoCompute, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoComputeUnion$inboundSchema: z.ZodType<DeploymentInfoComputeUnion, unknown>;
export declare function deploymentInfoComputeUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoComputeUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoDeploymentModel$inboundSchema: z.ZodEnum<typeof DeploymentInfoDeploymentModel>;
/** @internal */
export declare const DeploymentInfoAws$inboundSchema: z.ZodType<DeploymentInfoAws, unknown>;
export declare function deploymentInfoAwsFromJSON(jsonString: string): SafeParseResult<DeploymentInfoAws, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoAwsUnion$inboundSchema: z.ZodType<DeploymentInfoAwsUnion, unknown>;
export declare function deploymentInfoAwsUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoAwsUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoAzure$inboundSchema: z.ZodType<DeploymentInfoAzure, unknown>;
export declare function deploymentInfoAzureFromJSON(jsonString: string): SafeParseResult<DeploymentInfoAzure, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoAzureUnion$inboundSchema: z.ZodType<DeploymentInfoAzureUnion, unknown>;
export declare function deploymentInfoAzureUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoAzureUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoGcp$inboundSchema: z.ZodType<DeploymentInfoGcp, unknown>;
export declare function deploymentInfoGcpFromJSON(jsonString: string): SafeParseResult<DeploymentInfoGcp, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoGcpUnion$inboundSchema: z.ZodType<DeploymentInfoGcpUnion, unknown>;
export declare function deploymentInfoGcpUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoGcpUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoTlsSecretRef$inboundSchema: z.ZodType<DeploymentInfoTlsSecretRef, unknown>;
export declare function deploymentInfoTlsSecretRefFromJSON(jsonString: string): SafeParseResult<DeploymentInfoTlsSecretRef, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoDomainsKubernetes$inboundSchema: z.ZodType<DeploymentInfoDomainsKubernetes, unknown>;
export declare function deploymentInfoDomainsKubernetesFromJSON(jsonString: string): SafeParseResult<DeploymentInfoDomainsKubernetes, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoDomainsKubernetesUnion$inboundSchema: z.ZodType<DeploymentInfoDomainsKubernetesUnion, unknown>;
export declare function deploymentInfoDomainsKubernetesUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoDomainsKubernetesUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoDomainsCertificate$inboundSchema: z.ZodType<DeploymentInfoDomainsCertificate, unknown>;
export declare function deploymentInfoDomainsCertificateFromJSON(jsonString: string): SafeParseResult<DeploymentInfoDomainsCertificate, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCustomDomains$inboundSchema: z.ZodType<DeploymentInfoCustomDomains, unknown>;
export declare function deploymentInfoCustomDomainsFromJSON(jsonString: string): SafeParseResult<DeploymentInfoCustomDomains, SDKValidationError>;
/** @internal */
export declare const SetupUpdateModeLoadBalancer$inboundSchema: z.ZodEnum<typeof SetupUpdateModeLoadBalancer>;
/** @internal */
export declare const DeploymentInfoPublicEndpointTargetLoadBalancer$inboundSchema: z.ZodType<DeploymentInfoPublicEndpointTargetLoadBalancer, unknown>;
export declare function deploymentInfoPublicEndpointTargetLoadBalancerFromJSON(jsonString: string): SafeParseResult<DeploymentInfoPublicEndpointTargetLoadBalancer, SDKValidationError>;
/** @internal */
export declare const SetupUpdateModeMachineAddresses$inboundSchema: z.ZodEnum<typeof SetupUpdateModeMachineAddresses>;
/** @internal */
export declare const DeploymentInfoPublicEndpointTargetMachineAddresses$inboundSchema: z.ZodType<DeploymentInfoPublicEndpointTargetMachineAddresses, unknown>;
export declare function deploymentInfoPublicEndpointTargetMachineAddressesFromJSON(jsonString: string): SafeParseResult<DeploymentInfoPublicEndpointTargetMachineAddresses, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoPublicEndpointTargetUnion$inboundSchema: z.ZodType<DeploymentInfoPublicEndpointTargetUnion, unknown>;
export declare function deploymentInfoPublicEndpointTargetUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoPublicEndpointTargetUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoDomains$inboundSchema: z.ZodType<DeploymentInfoDomains, unknown>;
export declare function deploymentInfoDomainsFromJSON(jsonString: string): SafeParseResult<DeploymentInfoDomains, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoDomainsUnion$inboundSchema: z.ZodType<DeploymentInfoDomainsUnion, unknown>;
export declare function deploymentInfoDomainsUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoDomainsUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoExternalBindings$inboundSchema: z.ZodType<DeploymentInfoExternalBindings, unknown>;
export declare function deploymentInfoExternalBindingsFromJSON(jsonString: string): SafeParseResult<DeploymentInfoExternalBindings, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoHeartbeats$inboundSchema: z.ZodEnum<typeof DeploymentInfoHeartbeats>;
/** @internal */
export declare const DeploymentInfoCloud$inboundSchema: z.ZodType<DeploymentInfoCloud, unknown>;
export declare function deploymentInfoCloudFromJSON(jsonString: string): SafeParseResult<DeploymentInfoCloud, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCloudUnion$inboundSchema: z.ZodType<DeploymentInfoCloudUnion, unknown>;
export declare function deploymentInfoCloudUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoCloudUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoOwnership$inboundSchema: z.ZodEnum<typeof DeploymentInfoOwnership>;
/** @internal */
export declare const DeploymentInfoCluster$inboundSchema: z.ZodType<DeploymentInfoCluster, unknown>;
export declare function deploymentInfoClusterFromJSON(jsonString: string): SafeParseResult<DeploymentInfoCluster, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoClusterUnion$inboundSchema: z.ZodType<DeploymentInfoClusterUnion, unknown>;
export declare function deploymentInfoClusterUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoClusterUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCertificateNone2$inboundSchema: z.ZodType<DeploymentInfoCertificateNone2, unknown>;
export declare function deploymentInfoCertificateNone2FromJSON(jsonString: string): SafeParseResult<DeploymentInfoCertificateNone2, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCertificateManagedTLSSecret2$inboundSchema: z.ZodType<DeploymentInfoCertificateManagedTLSSecret2, unknown>;
export declare function deploymentInfoCertificateManagedTLSSecret2FromJSON(jsonString: string): SafeParseResult<DeploymentInfoCertificateManagedTLSSecret2, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCertificateAwsAcmArn2$inboundSchema: z.ZodType<DeploymentInfoCertificateAwsAcmArn2, unknown>;
export declare function deploymentInfoCertificateAwsAcmArn2FromJSON(jsonString: string): SafeParseResult<DeploymentInfoCertificateAwsAcmArn2, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCertificateManagedAcmImport2$inboundSchema: z.ZodType<DeploymentInfoCertificateManagedAcmImport2, unknown>;
export declare function deploymentInfoCertificateManagedAcmImport2FromJSON(jsonString: string): SafeParseResult<DeploymentInfoCertificateManagedAcmImport2, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCertificateTLSSecretRef2$inboundSchema: z.ZodType<DeploymentInfoCertificateTLSSecretRef2, unknown>;
export declare function deploymentInfoCertificateTLSSecretRef2FromJSON(jsonString: string): SafeParseResult<DeploymentInfoCertificateTLSSecretRef2, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCertificateUnion2$inboundSchema: z.ZodType<DeploymentInfoCertificateUnion2, unknown>;
export declare function deploymentInfoCertificateUnion2FromJSON(jsonString: string): SafeParseResult<DeploymentInfoCertificateUnion2, SDKValidationError>;
/** @internal */
export declare const SetupUpdateModeCustom$inboundSchema: z.ZodEnum<typeof SetupUpdateModeCustom>;
/** @internal */
export declare const SetupUpdateProviderAzureApplicationGatewayForContainersEnum4$inboundSchema: z.ZodEnum<typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum4>;
/** @internal */
export declare const ProviderSetupUpdateAzureApplicationGatewayForContainers4$inboundSchema: z.ZodType<ProviderSetupUpdateAzureApplicationGatewayForContainers4, unknown>;
export declare function providerSetupUpdateAzureApplicationGatewayForContainers4FromJSON(jsonString: string): SafeParseResult<ProviderSetupUpdateAzureApplicationGatewayForContainers4, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderGkeGatewayEnum4$inboundSchema: z.ZodEnum<typeof SetupUpdateProviderGkeGatewayEnum4>;
/** @internal */
export declare const ProviderSetupUpdateGkeGateway4$inboundSchema: z.ZodType<ProviderSetupUpdateGkeGateway4, unknown>;
export declare function providerSetupUpdateGkeGateway4FromJSON(jsonString: string): SafeParseResult<ProviderSetupUpdateGkeGateway4, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderAwsAlbEnum4$inboundSchema: z.ZodEnum<typeof SetupUpdateProviderAwsAlbEnum4>;
/** @internal */
export declare const ProviderSetupUpdateAwsAlb4$inboundSchema: z.ZodType<ProviderSetupUpdateAwsAlb4, unknown>;
export declare function providerSetupUpdateAwsAlb4FromJSON(jsonString: string): SafeParseResult<ProviderSetupUpdateAwsAlb4, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderUnion4$inboundSchema: z.ZodType<SetupUpdateProviderUnion4, unknown>;
export declare function setupUpdateProviderUnion4FromJSON(jsonString: string): SafeParseResult<SetupUpdateProviderUnion4, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoRouteGateway2$inboundSchema: z.ZodType<DeploymentInfoRouteGateway2, unknown>;
export declare function deploymentInfoRouteGateway2FromJSON(jsonString: string): SafeParseResult<DeploymentInfoRouteGateway2, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderAzureApplicationGatewayForContainersEnum3$inboundSchema: z.ZodEnum<typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum3>;
/** @internal */
export declare const ProviderSetupUpdateAzureApplicationGatewayForContainers3$inboundSchema: z.ZodType<ProviderSetupUpdateAzureApplicationGatewayForContainers3, unknown>;
export declare function providerSetupUpdateAzureApplicationGatewayForContainers3FromJSON(jsonString: string): SafeParseResult<ProviderSetupUpdateAzureApplicationGatewayForContainers3, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderGkeGatewayEnum3$inboundSchema: z.ZodEnum<typeof SetupUpdateProviderGkeGatewayEnum3>;
/** @internal */
export declare const ProviderSetupUpdateGkeGateway3$inboundSchema: z.ZodType<ProviderSetupUpdateGkeGateway3, unknown>;
export declare function providerSetupUpdateGkeGateway3FromJSON(jsonString: string): SafeParseResult<ProviderSetupUpdateGkeGateway3, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderAwsAlbEnum3$inboundSchema: z.ZodEnum<typeof SetupUpdateProviderAwsAlbEnum3>;
/** @internal */
export declare const ProviderSetupUpdateAwsAlb3$inboundSchema: z.ZodType<ProviderSetupUpdateAwsAlb3, unknown>;
export declare function providerSetupUpdateAwsAlb3FromJSON(jsonString: string): SafeParseResult<ProviderSetupUpdateAwsAlb3, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderUnion3$inboundSchema: z.ZodType<SetupUpdateProviderUnion3, unknown>;
export declare function setupUpdateProviderUnion3FromJSON(jsonString: string): SafeParseResult<SetupUpdateProviderUnion3, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoRouteIngress2$inboundSchema: z.ZodType<DeploymentInfoRouteIngress2, unknown>;
export declare function deploymentInfoRouteIngress2FromJSON(jsonString: string): SafeParseResult<DeploymentInfoRouteIngress2, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoRouteUnion2$inboundSchema: z.ZodType<DeploymentInfoRouteUnion2, unknown>;
export declare function deploymentInfoRouteUnion2FromJSON(jsonString: string): SafeParseResult<DeploymentInfoRouteUnion2, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoExposureCustom$inboundSchema: z.ZodType<DeploymentInfoExposureCustom, unknown>;
export declare function deploymentInfoExposureCustomFromJSON(jsonString: string): SafeParseResult<DeploymentInfoExposureCustom, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCertificateNone1$inboundSchema: z.ZodType<DeploymentInfoCertificateNone1, unknown>;
export declare function deploymentInfoCertificateNone1FromJSON(jsonString: string): SafeParseResult<DeploymentInfoCertificateNone1, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCertificateManagedTLSSecret1$inboundSchema: z.ZodType<DeploymentInfoCertificateManagedTLSSecret1, unknown>;
export declare function deploymentInfoCertificateManagedTLSSecret1FromJSON(jsonString: string): SafeParseResult<DeploymentInfoCertificateManagedTLSSecret1, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCertificateAwsAcmArn1$inboundSchema: z.ZodType<DeploymentInfoCertificateAwsAcmArn1, unknown>;
export declare function deploymentInfoCertificateAwsAcmArn1FromJSON(jsonString: string): SafeParseResult<DeploymentInfoCertificateAwsAcmArn1, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCertificateManagedAcmImport1$inboundSchema: z.ZodType<DeploymentInfoCertificateManagedAcmImport1, unknown>;
export declare function deploymentInfoCertificateManagedAcmImport1FromJSON(jsonString: string): SafeParseResult<DeploymentInfoCertificateManagedAcmImport1, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCertificateTLSSecretRef1$inboundSchema: z.ZodType<DeploymentInfoCertificateTLSSecretRef1, unknown>;
export declare function deploymentInfoCertificateTLSSecretRef1FromJSON(jsonString: string): SafeParseResult<DeploymentInfoCertificateTLSSecretRef1, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCertificateUnion1$inboundSchema: z.ZodType<DeploymentInfoCertificateUnion1, unknown>;
export declare function deploymentInfoCertificateUnion1FromJSON(jsonString: string): SafeParseResult<DeploymentInfoCertificateUnion1, SDKValidationError>;
/** @internal */
export declare const SetupUpdateModeGenerated$inboundSchema: z.ZodEnum<typeof SetupUpdateModeGenerated>;
/** @internal */
export declare const SetupUpdateProviderAzureApplicationGatewayForContainersEnum2$inboundSchema: z.ZodEnum<typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum2>;
/** @internal */
export declare const ProviderSetupUpdateAzureApplicationGatewayForContainers2$inboundSchema: z.ZodType<ProviderSetupUpdateAzureApplicationGatewayForContainers2, unknown>;
export declare function providerSetupUpdateAzureApplicationGatewayForContainers2FromJSON(jsonString: string): SafeParseResult<ProviderSetupUpdateAzureApplicationGatewayForContainers2, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderGkeGatewayEnum2$inboundSchema: z.ZodEnum<typeof SetupUpdateProviderGkeGatewayEnum2>;
/** @internal */
export declare const ProviderSetupUpdateGkeGateway2$inboundSchema: z.ZodType<ProviderSetupUpdateGkeGateway2, unknown>;
export declare function providerSetupUpdateGkeGateway2FromJSON(jsonString: string): SafeParseResult<ProviderSetupUpdateGkeGateway2, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderAwsAlbEnum2$inboundSchema: z.ZodEnum<typeof SetupUpdateProviderAwsAlbEnum2>;
/** @internal */
export declare const ProviderSetupUpdateAwsAlb2$inboundSchema: z.ZodType<ProviderSetupUpdateAwsAlb2, unknown>;
export declare function providerSetupUpdateAwsAlb2FromJSON(jsonString: string): SafeParseResult<ProviderSetupUpdateAwsAlb2, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderUnion2$inboundSchema: z.ZodType<SetupUpdateProviderUnion2, unknown>;
export declare function setupUpdateProviderUnion2FromJSON(jsonString: string): SafeParseResult<SetupUpdateProviderUnion2, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoRouteGateway1$inboundSchema: z.ZodType<DeploymentInfoRouteGateway1, unknown>;
export declare function deploymentInfoRouteGateway1FromJSON(jsonString: string): SafeParseResult<DeploymentInfoRouteGateway1, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderAzureApplicationGatewayForContainersEnum1$inboundSchema: z.ZodEnum<typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum1>;
/** @internal */
export declare const ProviderSetupUpdateAzureApplicationGatewayForContainers1$inboundSchema: z.ZodType<ProviderSetupUpdateAzureApplicationGatewayForContainers1, unknown>;
export declare function providerSetupUpdateAzureApplicationGatewayForContainers1FromJSON(jsonString: string): SafeParseResult<ProviderSetupUpdateAzureApplicationGatewayForContainers1, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderGkeGatewayEnum1$inboundSchema: z.ZodEnum<typeof SetupUpdateProviderGkeGatewayEnum1>;
/** @internal */
export declare const ProviderSetupUpdateGkeGateway1$inboundSchema: z.ZodType<ProviderSetupUpdateGkeGateway1, unknown>;
export declare function providerSetupUpdateGkeGateway1FromJSON(jsonString: string): SafeParseResult<ProviderSetupUpdateGkeGateway1, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderAwsAlbEnum1$inboundSchema: z.ZodEnum<typeof SetupUpdateProviderAwsAlbEnum1>;
/** @internal */
export declare const ProviderSetupUpdateAwsAlb1$inboundSchema: z.ZodType<ProviderSetupUpdateAwsAlb1, unknown>;
export declare function providerSetupUpdateAwsAlb1FromJSON(jsonString: string): SafeParseResult<ProviderSetupUpdateAwsAlb1, SDKValidationError>;
/** @internal */
export declare const SetupUpdateProviderUnion1$inboundSchema: z.ZodType<SetupUpdateProviderUnion1, unknown>;
export declare function setupUpdateProviderUnion1FromJSON(jsonString: string): SafeParseResult<SetupUpdateProviderUnion1, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoRouteIngress1$inboundSchema: z.ZodType<DeploymentInfoRouteIngress1, unknown>;
export declare function deploymentInfoRouteIngress1FromJSON(jsonString: string): SafeParseResult<DeploymentInfoRouteIngress1, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoRouteUnion1$inboundSchema: z.ZodType<DeploymentInfoRouteUnion1, unknown>;
export declare function deploymentInfoRouteUnion1FromJSON(jsonString: string): SafeParseResult<DeploymentInfoRouteUnion1, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoExposureGenerated$inboundSchema: z.ZodType<DeploymentInfoExposureGenerated, unknown>;
export declare function deploymentInfoExposureGeneratedFromJSON(jsonString: string): SafeParseResult<DeploymentInfoExposureGenerated, SDKValidationError>;
/** @internal */
export declare const SetupUpdateModeDisabled$inboundSchema: z.ZodEnum<typeof SetupUpdateModeDisabled>;
/** @internal */
export declare const DeploymentInfoExposureDisabled$inboundSchema: z.ZodType<DeploymentInfoExposureDisabled, unknown>;
export declare function deploymentInfoExposureDisabledFromJSON(jsonString: string): SafeParseResult<DeploymentInfoExposureDisabled, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoExposureUnion$inboundSchema: z.ZodType<DeploymentInfoExposureUnion, unknown>;
export declare function deploymentInfoExposureUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoExposureUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoKubernetes$inboundSchema: z.ZodType<DeploymentInfoKubernetes, unknown>;
export declare function deploymentInfoKubernetesFromJSON(jsonString: string): SafeParseResult<DeploymentInfoKubernetes, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoKubernetesUnion$inboundSchema: z.ZodType<DeploymentInfoKubernetesUnion, unknown>;
export declare function deploymentInfoKubernetesUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoKubernetesUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoTypeByoVnetAzure$inboundSchema: z.ZodEnum<typeof DeploymentInfoTypeByoVnetAzure>;
/** @internal */
export declare const DeploymentInfoNetworkByoVnetAzure$inboundSchema: z.ZodType<DeploymentInfoNetworkByoVnetAzure, unknown>;
export declare function deploymentInfoNetworkByoVnetAzureFromJSON(jsonString: string): SafeParseResult<DeploymentInfoNetworkByoVnetAzure, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoTypeByoVpcGcp$inboundSchema: z.ZodEnum<typeof DeploymentInfoTypeByoVpcGcp>;
/** @internal */
export declare const DeploymentInfoNetworkByoVpcGcp$inboundSchema: z.ZodType<DeploymentInfoNetworkByoVpcGcp, unknown>;
export declare function deploymentInfoNetworkByoVpcGcpFromJSON(jsonString: string): SafeParseResult<DeploymentInfoNetworkByoVpcGcp, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoTypeByoVpcAws$inboundSchema: z.ZodEnum<typeof DeploymentInfoTypeByoVpcAws>;
/** @internal */
export declare const DeploymentInfoNetworkByoVpcAws$inboundSchema: z.ZodType<DeploymentInfoNetworkByoVpcAws, unknown>;
export declare function deploymentInfoNetworkByoVpcAwsFromJSON(jsonString: string): SafeParseResult<DeploymentInfoNetworkByoVpcAws, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoTypeCreate$inboundSchema: z.ZodEnum<typeof DeploymentInfoTypeCreate>;
/** @internal */
export declare const DeploymentInfoNetworkCreate$inboundSchema: z.ZodType<DeploymentInfoNetworkCreate, unknown>;
export declare function deploymentInfoNetworkCreateFromJSON(jsonString: string): SafeParseResult<DeploymentInfoNetworkCreate, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoTypeUseDefault$inboundSchema: z.ZodEnum<typeof DeploymentInfoTypeUseDefault>;
/** @internal */
export declare const DeploymentInfoNetworkUseDefault$inboundSchema: z.ZodType<DeploymentInfoNetworkUseDefault, unknown>;
export declare function deploymentInfoNetworkUseDefaultFromJSON(jsonString: string): SafeParseResult<DeploymentInfoNetworkUseDefault, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoNetworkUnion$inboundSchema: z.ZodType<DeploymentInfoNetworkUnion, unknown>;
export declare function deploymentInfoNetworkUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoNetworkUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoTelemetry$inboundSchema: z.ZodEnum<typeof DeploymentInfoTelemetry>;
/** @internal */
export declare const DeploymentInfoUpdates$inboundSchema: z.ZodEnum<typeof DeploymentInfoUpdates>;
/** @internal */
export declare const DeploymentInfoStackSettings$inboundSchema: z.ZodType<DeploymentInfoStackSettings, unknown>;
export declare function deploymentInfoStackSettingsFromJSON(jsonString: string): SafeParseResult<DeploymentInfoStackSettings, SDKValidationError>;
/** @internal */
export declare const SetupUpdate$inboundSchema: z.ZodType<SetupUpdate, unknown>;
export declare function setupUpdateFromJSON(jsonString: string): SafeParseResult<SetupUpdate, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoTokenType$inboundSchema: z.ZodEnum<typeof DeploymentInfoTokenType>;
/** @internal */
export declare const DeploymentInfoDeploymentPlatform$inboundSchema: z.ZodEnum<typeof DeploymentInfoDeploymentPlatform>;
/** @internal */
export declare const DeploymentInfoDeployment$inboundSchema: z.ZodType<DeploymentInfoDeployment, unknown>;
export declare function deploymentInfoDeploymentFromJSON(jsonString: string): SafeParseResult<DeploymentInfoDeployment, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoDeploymentGroup$inboundSchema: z.ZodType<DeploymentInfoDeploymentGroup, unknown>;
export declare function deploymentInfoDeploymentGroupFromJSON(jsonString: string): SafeParseResult<DeploymentInfoDeploymentGroup, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoWorkspace$inboundSchema: z.ZodType<DeploymentInfoWorkspace, unknown>;
export declare function deploymentInfoWorkspaceFromJSON(jsonString: string): SafeParseResult<DeploymentInfoWorkspace, SDKValidationError>;
/** @internal */
export declare const Portal$inboundSchema: z.ZodType<Portal, unknown>;
export declare function portalFromJSON(jsonString: string): SafeParseResult<Portal, SDKValidationError>;
/** @internal */
export declare const StackSummaryPlatform$inboundSchema: z.ZodEnum<typeof StackSummaryPlatform>;
/** @internal */
export declare const ResourceCounts$inboundSchema: z.ZodType<ResourceCounts, unknown>;
export declare function resourceCountsFromJSON(jsonString: string): SafeParseResult<ResourceCounts, SDKValidationError>;
/** @internal */
export declare const PublicEndpoint$inboundSchema: z.ZodType<PublicEndpoint, unknown>;
export declare function publicEndpointFromJSON(jsonString: string): SafeParseResult<PublicEndpoint, SDKValidationError>;
/** @internal */
export declare const StackSummary$inboundSchema: z.ZodType<StackSummary, unknown>;
export declare function stackSummaryFromJSON(jsonString: string): SafeParseResult<StackSummary, SDKValidationError>;
/** @internal */
export declare const GeneratedDomain$inboundSchema: z.ZodType<GeneratedDomain, unknown>;
export declare function generatedDomainFromJSON(jsonString: string): SafeParseResult<GeneratedDomain, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoProject$inboundSchema: z.ZodType<DeploymentInfoProject, unknown>;
export declare function deploymentInfoProjectFromJSON(jsonString: string): SafeParseResult<DeploymentInfoProject, SDKValidationError>;
/** @internal */
export declare const CliStatus$inboundSchema: z.ZodEnum<typeof CliStatus>;
/** @internal */
export declare const DeploymentInfoBinaries$inboundSchema: z.ZodType<DeploymentInfoBinaries, unknown>;
export declare function deploymentInfoBinariesFromJSON(jsonString: string): SafeParseResult<DeploymentInfoBinaries, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoBuildInfo$inboundSchema: z.ZodType<DeploymentInfoBuildInfo, unknown>;
export declare function deploymentInfoBuildInfoFromJSON(jsonString: string): SafeParseResult<DeploymentInfoBuildInfo, SDKValidationError>;
/** @internal */
export declare const CliOutputs$inboundSchema: z.ZodType<CliOutputs, unknown>;
export declare function cliOutputsFromJSON(jsonString: string): SafeParseResult<CliOutputs, SDKValidationError>;
/** @internal */
export declare const InstallScripts$inboundSchema: z.ZodType<InstallScripts, unknown>;
export declare function installScriptsFromJSON(jsonString: string): SafeParseResult<InstallScripts, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoCli$inboundSchema: z.ZodType<DeploymentInfoCli, unknown>;
export declare function deploymentInfoCliFromJSON(jsonString: string): SafeParseResult<DeploymentInfoCli, SDKValidationError>;
/** @internal */
export declare const CloudformationStatus$inboundSchema: z.ZodEnum<typeof CloudformationStatus>;
/** @internal */
export declare const CloudformationTargets$inboundSchema: z.ZodType<CloudformationTargets, unknown>;
export declare function cloudformationTargetsFromJSON(jsonString: string): SafeParseResult<CloudformationTargets, SDKValidationError>;
/** @internal */
export declare const CloudformationOutputs$inboundSchema: z.ZodType<CloudformationOutputs, unknown>;
export declare function cloudformationOutputsFromJSON(jsonString: string): SafeParseResult<CloudformationOutputs, SDKValidationError>;
/** @internal */
export declare const CloudformationMode$inboundSchema: z.ZodEnum<typeof CloudformationMode>;
/** @internal */
export declare const DeploymentInfoCloudformation$inboundSchema: z.ZodType<DeploymentInfoCloudformation, unknown>;
export declare function deploymentInfoCloudformationFromJSON(jsonString: string): SafeParseResult<DeploymentInfoCloudformation, SDKValidationError>;
/** @internal */
export declare const TerraformStatus$inboundSchema: z.ZodEnum<typeof TerraformStatus>;
/** @internal */
export declare const DeploymentInfoModules$inboundSchema: z.ZodType<DeploymentInfoModules, unknown>;
export declare function deploymentInfoModulesFromJSON(jsonString: string): SafeParseResult<DeploymentInfoModules, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoGpgPublicKey$inboundSchema: z.ZodType<DeploymentInfoGpgPublicKey, unknown>;
export declare function deploymentInfoGpgPublicKeyFromJSON(jsonString: string): SafeParseResult<DeploymentInfoGpgPublicKey, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoPlatforms$inboundSchema: z.ZodType<DeploymentInfoPlatforms, unknown>;
export declare function deploymentInfoPlatformsFromJSON(jsonString: string): SafeParseResult<DeploymentInfoPlatforms, SDKValidationError>;
/** @internal */
export declare const TerraformProvider$inboundSchema: z.ZodType<TerraformProvider, unknown>;
export declare function terraformProviderFromJSON(jsonString: string): SafeParseResult<TerraformProvider, SDKValidationError>;
/** @internal */
export declare const TerraformOutputs$inboundSchema: z.ZodType<TerraformOutputs, unknown>;
export declare function terraformOutputsFromJSON(jsonString: string): SafeParseResult<TerraformOutputs, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoTerraform$inboundSchema: z.ZodType<DeploymentInfoTerraform, unknown>;
export declare function deploymentInfoTerraformFromJSON(jsonString: string): SafeParseResult<DeploymentInfoTerraform, SDKValidationError>;
/** @internal */
export declare const HelmStatus$inboundSchema: z.ZodEnum<typeof HelmStatus>;
/** @internal */
export declare const HelmOutputs$inboundSchema: z.ZodType<HelmOutputs, unknown>;
export declare function helmOutputsFromJSON(jsonString: string): SafeParseResult<HelmOutputs, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoHelm$inboundSchema: z.ZodType<DeploymentInfoHelm, unknown>;
export declare function deploymentInfoHelmFromJSON(jsonString: string): SafeParseResult<DeploymentInfoHelm, SDKValidationError>;
/** @internal */
export declare const Packages$inboundSchema: z.ZodType<Packages, unknown>;
export declare function packagesFromJSON(jsonString: string): SafeParseResult<Packages, SDKValidationError>;
/** @internal */
export declare const TargetsPlatform$inboundSchema: z.ZodEnum<typeof TargetsPlatform>;
/** @internal */
export declare const TargetsPlatformKubernetes$inboundSchema: z.ZodEnum<typeof TargetsPlatformKubernetes>;
/** @internal */
export declare const DeploymentInfoManagementConfigKubernetes$inboundSchema: z.ZodType<DeploymentInfoManagementConfigKubernetes, unknown>;
export declare function deploymentInfoManagementConfigKubernetesFromJSON(jsonString: string): SafeParseResult<DeploymentInfoManagementConfigKubernetes, SDKValidationError>;
/** @internal */
export declare const TargetsPlatformAzure$inboundSchema: z.ZodEnum<typeof TargetsPlatformAzure>;
/** @internal */
export declare const DeploymentInfoManagementConfigAzure$inboundSchema: z.ZodType<DeploymentInfoManagementConfigAzure, unknown>;
export declare function deploymentInfoManagementConfigAzureFromJSON(jsonString: string): SafeParseResult<DeploymentInfoManagementConfigAzure, SDKValidationError>;
/** @internal */
export declare const TargetsPlatformGcp$inboundSchema: z.ZodEnum<typeof TargetsPlatformGcp>;
/** @internal */
export declare const DeploymentInfoManagementConfigGcp$inboundSchema: z.ZodType<DeploymentInfoManagementConfigGcp, unknown>;
export declare function deploymentInfoManagementConfigGcpFromJSON(jsonString: string): SafeParseResult<DeploymentInfoManagementConfigGcp, SDKValidationError>;
/** @internal */
export declare const TargetsPlatformAws$inboundSchema: z.ZodEnum<typeof TargetsPlatformAws>;
/** @internal */
export declare const DeploymentInfoManagementConfigAws$inboundSchema: z.ZodType<DeploymentInfoManagementConfigAws, unknown>;
export declare function deploymentInfoManagementConfigAwsFromJSON(jsonString: string): SafeParseResult<DeploymentInfoManagementConfigAws, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoManagementConfigUnion$inboundSchema: z.ZodType<DeploymentInfoManagementConfigUnion, unknown>;
export declare function deploymentInfoManagementConfigUnionFromJSON(jsonString: string): SafeParseResult<DeploymentInfoManagementConfigUnion, SDKValidationError>;
/** @internal */
export declare const InstallContextTargets$inboundSchema: z.ZodType<InstallContextTargets, unknown>;
export declare function installContextTargetsFromJSON(jsonString: string): SafeParseResult<InstallContextTargets, SDKValidationError>;
/** @internal */
export declare const DeploymentInfoInstallContext$inboundSchema: z.ZodType<DeploymentInfoInstallContext, unknown>;
export declare function deploymentInfoInstallContextFromJSON(jsonString: string): SafeParseResult<DeploymentInfoInstallContext, SDKValidationError>;
/** @internal */
export declare const ModelAvailabilitySourceStatus$inboundSchema: z.ZodEnum<typeof ModelAvailabilitySourceStatus>;
/** @internal */
export declare const ModelAvailabilitySource$inboundSchema: z.ZodType<ModelAvailabilitySource, unknown>;
export declare function modelAvailabilitySourceFromJSON(jsonString: string): SafeParseResult<ModelAvailabilitySource, SDKValidationError>;
/** @internal */
export declare const ReadinessStatus$inboundSchema: z.ZodEnum<typeof ReadinessStatus>;
/** @internal */
export declare const CheckStatus$inboundSchema: z.ZodEnum<typeof CheckStatus>;
/** @internal */
export declare const Check$inboundSchema: z.ZodType<Check, unknown>;
export declare function checkFromJSON(jsonString: string): SafeParseResult<Check, SDKValidationError>;
/** @internal */
export declare const Readiness$inboundSchema: z.ZodType<Readiness, unknown>;
export declare function readinessFromJSON(jsonString: string): SafeParseResult<Readiness, SDKValidationError>;
/** @internal */
export declare const DeploymentInfo$inboundSchema: z.ZodType<DeploymentInfo, unknown>;
export declare function deploymentInfoFromJSON(jsonString: string): SafeParseResult<DeploymentInfo, SDKValidationError>;
//# sourceMappingURL=deploymentinfo.d.ts.map