import * as z from "zod/v4";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import { DeploymentPurpose } from "./deploymentpurpose.js";
import { DeploymentUpdateOperationSummary } from "./deploymentupdateoperationsummary.js";
import { SDKValidationError } from "./errors/sdkvalidationerror.js";
import { OperatorCapabilityReport } from "./operatorcapabilityreport.js";
import { ReportedOperation } from "./reportedoperation.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 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 | any;
/**
 * 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 | any;
export type DeploymentPoolsAutoscale = {
    failureDomains?: DeploymentFailureDomains2 | 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 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 | any;
export type DeploymentPoolsFixed = {
    failureDomains?: DeploymentFailureDomains1 | 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 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 = {
    /**
     * Selected compute choices keyed by pool ID.
     */
    pools?: {
        [k: string]: DeploymentPoolsFixed | DeploymentPoolsAutoscale;
    } | undefined;
};
export type DeploymentComputeUnion = DeploymentCompute | any;
/**
 * 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 | any;
export type DeploymentAzureStackSettings = {
    keyVaultCertificateId: string;
    keyVaultResourceId?: string | null | undefined;
};
export type DeploymentAzureUnion = DeploymentAzureStackSettings | any;
export type DeploymentGcpStackSettings = {
    certificateName: string;
};
export type DeploymentGcpUnion = DeploymentGcpStackSettings | any;
/**
 * 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 | any;
/**
 * Platform-specific certificate references for custom domains.
 */
export type DeploymentDomainsCertificate = {
    aws?: DeploymentAws | any | null | undefined;
    azure?: DeploymentAzureStackSettings | any | null | undefined;
    gcp?: DeploymentGcpStackSettings | any | null | undefined;
    kubernetes?: DeploymentDomainsKubernetes | any | 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 | 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 DeploymentDomains = {
    /**
     * Custom domain configuration per resource ID.
     */
    customDomains?: {
        [k: string]: DeploymentCustomDomains;
    } | null | undefined;
    publicEndpointTarget?: DeploymentPublicEndpointTargetLoadBalancer | DeploymentPublicEndpointTargetMachineAddresses | any | null | undefined;
};
export type DeploymentDomainsUnion = DeploymentDomains | 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 DeploymentExternalBindings = {};
/**
 * 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 | any;
/**
 * 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 | any | 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 | any;
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 | any;
/**
 * 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 | any | 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 | any;
/**
 * 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 | any | 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 | any;
/**
 * 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 | any | 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 | any;
/**
 * 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 | any | 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 | 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 DeploymentKubernetes = {
    cluster?: DeploymentCluster | any | null | undefined;
    exposure?: DeploymentExposureCustom | DeploymentExposureGenerated | DeploymentExposureDisabled | any | null | undefined;
};
export type DeploymentKubernetesUnion = DeploymentKubernetes | any;
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 | any;
/**
 * 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 | any | null | undefined;
    /**
     * Deployment model: how updates are delivered to the remote environment.
     */
    deploymentModel?: DeploymentDeploymentModel | undefined;
    domains?: DeploymentDomains | 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?: DeploymentExternalBindings | null | undefined;
    /**
     * How heartbeat health checks are handled.
     */
    heartbeats?: DeploymentHeartbeats | undefined;
    kubernetes?: DeploymentKubernetes | any | null | undefined;
    network?: DeploymentNetworkByoVpcAws | DeploymentNetworkByoVpcGcp | DeploymentNetworkByoVnetAzure | DeploymentNetworkUseDefault | DeploymentNetworkCreate | 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?: 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 | any;
/**
 * 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 | any;
/**
 * 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 | any;
/**
 * 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 | any;
/**
 * 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 | any;
/**
 * 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 | any | 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 | any | 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 | any | null | undefined;
    outputs?: DeploymentOutputs | any | null | undefined;
    previousConfig?: DeploymentPreviousConfig | any | 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;
    };
};
/**
 * 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 | any;
/**
 * Environment variable handling for a stack input mapping.
 */
export declare const DeploymentPendingPreparedStackTypeEnvEnum: {
    readonly Plain: "plain";
    readonly Secret: "secret";
};
/**
 * Environment variable handling for a stack input mapping.
 */
export type DeploymentPendingPreparedStackTypeEnvEnum = ClosedEnum<typeof DeploymentPendingPreparedStackTypeEnvEnum>;
export type DeploymentPendingPreparedStackTypeUnion = DeploymentPendingPreparedStackTypeEnvEnum | any;
/**
 * How a resolved stack input is injected into runtime environment variables.
 */
export type DeploymentPendingPreparedStackEnv = {
    /**
     * Environment variable name.
     */
    name: string;
    /**
     * Target resource IDs or patterns. None means every env-capable resource.
     */
    targetResources?: Array<string> | null | undefined;
    type?: DeploymentPendingPreparedStackTypeEnvEnum | any | null | undefined;
};
/**
 * Primitive stack input kind.
 */
export declare const DeploymentPendingPreparedStackKind: {
    readonly String: "string";
    readonly Secret: "secret";
    readonly Number: "number";
    readonly Integer: "integer";
    readonly Boolean: "boolean";
    readonly Enum: "enum";
    readonly StringList: "stringList";
};
/**
 * Primitive stack input kind.
 */
export type DeploymentPendingPreparedStackKind = ClosedEnum<typeof DeploymentPendingPreparedStackKind>;
/**
 * Represents the target cloud platform.
 */
export declare const DeploymentPendingPreparedStackPlatform: {
    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 DeploymentPendingPreparedStackPlatform = ClosedEnum<typeof DeploymentPendingPreparedStackPlatform>;
/**
 * Who can provide a stack input value.
 */
export declare const DeploymentPendingPreparedStackProvidedBy: {
    readonly Developer: "developer";
    readonly Deployer: "deployer";
};
/**
 * Who can provide a stack input value.
 */
export type DeploymentPendingPreparedStackProvidedBy = ClosedEnum<typeof DeploymentPendingPreparedStackProvidedBy>;
/**
 * Portable stack input validation constraints.
 */
export type DeploymentPendingPreparedStackValidation = {
    /**
     * Semantic format hint such as url.
     */
    format?: string | null | undefined;
    /**
     * Maximum number.
     */
    max?: string | null | undefined;
    /**
     * Maximum string-list items.
     */
    maxItems?: number | null | undefined;
    /**
     * Maximum string length.
     */
    maxLength?: number | null | undefined;
    /**
     * Minimum number.
     */
    min?: string | null | undefined;
    /**
     * Minimum string-list items.
     */
    minItems?: number | null | undefined;
    /**
     * Minimum string length.
     */
    minLength?: number | null | undefined;
    /**
     * Portable whole-value regex pattern.
     */
    pattern?: string | null | undefined;
    /**
     * Allowed string enum values.
     */
    values?: Array<string> | null | undefined;
};
export type DeploymentPendingPreparedStackValidationUnion = DeploymentPendingPreparedStackValidation | any;
/**
 * Stack input definition serialized into a release stack.
 */
export type DeploymentPendingPreparedStackInput = {
    default?: DeploymentPendingPreparedStackDefaultString | DeploymentPendingPreparedStackDefaultNumber | DeploymentPendingPreparedStackDefaultBoolean | DeploymentPendingPreparedStackDefaultStringList | any | null | undefined;
    /**
     * Human-facing helper text.
     */
    description: string;
    /**
     * Runtime env-var mappings for v1 input resolution.
     */
    env?: Array<DeploymentPendingPreparedStackEnv> | undefined;
    /**
     * Stable input ID used by CLI/API calls.
     */
    id: string;
    /**
     * Primitive stack input kind.
     */
    kind: DeploymentPendingPreparedStackKind;
    /**
     * Human-facing field label.
     */
    label: string;
    /**
     * Example placeholder shown in UI.
     */
    placeholder?: string | null | undefined;
    /**
     * Platforms where this input applies.
     */
    platforms?: Array<DeploymentPendingPreparedStackPlatform> | null | undefined;
    /**
     * Who can provide this value.
     */
    providedBy: Array<DeploymentPendingPreparedStackProvidedBy>;
    /**
     * Whether a resolved value is required before deployment can proceed.
     */
    required: boolean;
    validation?: DeploymentPendingPreparedStackValidation | any | null | undefined;
};
export declare const DeploymentPendingPreparedStackManagementEnum: {
    readonly Auto: "auto";
};
export type DeploymentPendingPreparedStackManagementEnum = ClosedEnum<typeof DeploymentPendingPreparedStackManagementEnum>;
/**
 * AWS-specific binding specification
 */
export type DeploymentPendingPreparedStackOverrideAwResource = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * AWS-specific binding specification
 */
export type DeploymentPendingPreparedStackOverrideAwStack = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackOverrideAwBinding = {
    /**
     * AWS-specific binding specification
     */
    resource?: DeploymentPendingPreparedStackOverrideAwResource | undefined;
    /**
     * AWS-specific binding specification
     */
    stack?: DeploymentPendingPreparedStackOverrideAwStack | undefined;
};
/**
 * IAM effect. Defaults to Allow.
 */
export declare const DeploymentPendingPreparedStackOverrideEffect: {
    readonly Allow: "Allow";
    readonly Deny: "Deny";
};
/**
 * IAM effect. Defaults to Allow.
 */
export type DeploymentPendingPreparedStackOverrideEffect = ClosedEnum<typeof DeploymentPendingPreparedStackOverrideEffect>;
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackOverrideAwGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * AWS-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackOverrideAw = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPendingPreparedStackOverrideAwBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * IAM effect. Defaults to Allow.
     */
    effect?: DeploymentPendingPreparedStackOverrideEffect | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPendingPreparedStackOverrideAwGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Azure-specific binding specification
 */
export type DeploymentPendingPreparedStackOverrideAzureResource = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Azure-specific binding specification
 */
export type DeploymentPendingPreparedStackOverrideAzureStack = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackOverrideAzureBinding = {
    /**
     * Azure-specific binding specification
     */
    resource?: DeploymentPendingPreparedStackOverrideAzureResource | undefined;
    /**
     * Azure-specific binding specification
     */
    stack?: DeploymentPendingPreparedStackOverrideAzureStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackOverrideAzureGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * Azure-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackOverrideAzure = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPendingPreparedStackOverrideAzureBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPendingPreparedStackOverrideAzureGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * GCP IAM condition
 */
export type DeploymentPendingPreparedStackOverrideConditionResource = {
    expression: string;
    title: string;
};
export type DeploymentPendingPreparedStackOverrideResourceConditionUnion = DeploymentPendingPreparedStackOverrideConditionResource | any;
/**
 * GCP-specific binding specification
 */
export type DeploymentPendingPreparedStackOverrideGcpResource = {
    condition?: DeploymentPendingPreparedStackOverrideConditionResource | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * GCP IAM condition
 */
export type DeploymentPendingPreparedStackOverrideConditionStack = {
    expression: string;
    title: string;
};
export type DeploymentPendingPreparedStackOverrideStackConditionUnion = DeploymentPendingPreparedStackOverrideConditionStack | any;
/**
 * GCP-specific binding specification
 */
export type DeploymentPendingPreparedStackOverrideGcpStack = {
    condition?: DeploymentPendingPreparedStackOverrideConditionStack | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackOverrideGcpBinding = {
    /**
     * GCP-specific binding specification
     */
    resource?: DeploymentPendingPreparedStackOverrideGcpResource | undefined;
    /**
     * GCP-specific binding specification
     */
    stack?: DeploymentPendingPreparedStackOverrideGcpStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackOverrideGcpGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * GCP-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackOverrideGcp = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPendingPreparedStackOverrideGcpBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPendingPreparedStackOverrideGcpGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Platform-specific permission configurations
 */
export type DeploymentPendingPreparedStackOverridePlatforms = {
    /**
     * AWS permission configurations
     */
    aws?: Array<DeploymentPendingPreparedStackOverrideAw> | null | undefined;
    /**
     * Azure permission configurations
     */
    azure?: Array<DeploymentPendingPreparedStackOverrideAzure> | null | undefined;
    /**
     * GCP permission configurations
     */
    gcp?: Array<DeploymentPendingPreparedStackOverrideGcp> | null | undefined;
};
/**
 * A permission set that can be applied across different cloud platforms
 */
export type DeploymentPendingPreparedStackOverride = {
    /**
     * Human-readable description of what this permission set allows
     */
    description: string;
    /**
     * Unique identifier for the permission set (e.g., "storage/data-read")
     */
    id: string;
    /**
     * Platform-specific permission configurations
     */
    platforms: DeploymentPendingPreparedStackOverridePlatforms;
};
/**
 * Reference to a permission set - either by name or inline definition
 */
export type DeploymentPendingPreparedStackOverrideUnion = DeploymentPendingPreparedStackOverride | string;
export type DeploymentPendingPreparedStackManagement2 = {
    /**
     * Permission profile that maps resources to permission sets
     *
     * @remarks
     * Key can be "*" for all resources or resource name for specific resource
     */
    override: {
        [k: string]: Array<DeploymentPendingPreparedStackOverride | string>;
    };
};
/**
 * AWS-specific binding specification
 */
export type DeploymentPendingPreparedStackExtendAwResource = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * AWS-specific binding specification
 */
export type DeploymentPendingPreparedStackExtendAwStack = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackExtendAwBinding = {
    /**
     * AWS-specific binding specification
     */
    resource?: DeploymentPendingPreparedStackExtendAwResource | undefined;
    /**
     * AWS-specific binding specification
     */
    stack?: DeploymentPendingPreparedStackExtendAwStack | undefined;
};
/**
 * IAM effect. Defaults to Allow.
 */
export declare const DeploymentPendingPreparedStackExtendEffect: {
    readonly Allow: "Allow";
    readonly Deny: "Deny";
};
/**
 * IAM effect. Defaults to Allow.
 */
export type DeploymentPendingPreparedStackExtendEffect = ClosedEnum<typeof DeploymentPendingPreparedStackExtendEffect>;
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackExtendAwGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * AWS-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackExtendAw = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPendingPreparedStackExtendAwBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * IAM effect. Defaults to Allow.
     */
    effect?: DeploymentPendingPreparedStackExtendEffect | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPendingPreparedStackExtendAwGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Azure-specific binding specification
 */
export type DeploymentPendingPreparedStackExtendAzureResource = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Azure-specific binding specification
 */
export type DeploymentPendingPreparedStackExtendAzureStack = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackExtendAzureBinding = {
    /**
     * Azure-specific binding specification
     */
    resource?: DeploymentPendingPreparedStackExtendAzureResource | undefined;
    /**
     * Azure-specific binding specification
     */
    stack?: DeploymentPendingPreparedStackExtendAzureStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackExtendAzureGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * Azure-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackExtendAzure = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPendingPreparedStackExtendAzureBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPendingPreparedStackExtendAzureGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * GCP IAM condition
 */
export type DeploymentPendingPreparedStackExtendConditionResource = {
    expression: string;
    title: string;
};
export type DeploymentPendingPreparedStackExtendResourceConditionUnion = DeploymentPendingPreparedStackExtendConditionResource | any;
/**
 * GCP-specific binding specification
 */
export type DeploymentPendingPreparedStackExtendGcpResource = {
    condition?: DeploymentPendingPreparedStackExtendConditionResource | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * GCP IAM condition
 */
export type DeploymentPendingPreparedStackExtendConditionStack = {
    expression: string;
    title: string;
};
export type DeploymentPendingPreparedStackExtendStackConditionUnion = DeploymentPendingPreparedStackExtendConditionStack | any;
/**
 * GCP-specific binding specification
 */
export type DeploymentPendingPreparedStackExtendGcpStack = {
    condition?: DeploymentPendingPreparedStackExtendConditionStack | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackExtendGcpBinding = {
    /**
     * GCP-specific binding specification
     */
    resource?: DeploymentPendingPreparedStackExtendGcpResource | undefined;
    /**
     * GCP-specific binding specification
     */
    stack?: DeploymentPendingPreparedStackExtendGcpStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackExtendGcpGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * GCP-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackExtendGcp = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPendingPreparedStackExtendGcpBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPendingPreparedStackExtendGcpGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Platform-specific permission configurations
 */
export type DeploymentPendingPreparedStackExtendPlatforms = {
    /**
     * AWS permission configurations
     */
    aws?: Array<DeploymentPendingPreparedStackExtendAw> | null | undefined;
    /**
     * Azure permission configurations
     */
    azure?: Array<DeploymentPendingPreparedStackExtendAzure> | null | undefined;
    /**
     * GCP permission configurations
     */
    gcp?: Array<DeploymentPendingPreparedStackExtendGcp> | null | undefined;
};
/**
 * A permission set that can be applied across different cloud platforms
 */
export type DeploymentPendingPreparedStackExtend = {
    /**
     * Human-readable description of what this permission set allows
     */
    description: string;
    /**
     * Unique identifier for the permission set (e.g., "storage/data-read")
     */
    id: string;
    /**
     * Platform-specific permission configurations
     */
    platforms: DeploymentPendingPreparedStackExtendPlatforms;
};
/**
 * Reference to a permission set - either by name or inline definition
 */
export type DeploymentPendingPreparedStackExtendUnion = DeploymentPendingPreparedStackExtend | string;
export type DeploymentPendingPreparedStackManagement1 = {
    /**
     * Permission profile that maps resources to permission sets
     *
     * @remarks
     * Key can be "*" for all resources or resource name for specific resource
     */
    extend: {
        [k: string]: Array<DeploymentPendingPreparedStackExtend | string>;
    };
};
/**
 * Management permissions configuration for stack management access
 */
export type DeploymentPendingPreparedStackManagementUnion = DeploymentPendingPreparedStackManagement1 | DeploymentPendingPreparedStackManagement2 | DeploymentPendingPreparedStackManagementEnum;
/**
 * AWS-specific binding specification
 */
export type DeploymentPendingPreparedStackProfileAwResource = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * AWS-specific binding specification
 */
export type DeploymentPendingPreparedStackProfileAwStack = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackProfileAwBinding = {
    /**
     * AWS-specific binding specification
     */
    resource?: DeploymentPendingPreparedStackProfileAwResource | undefined;
    /**
     * AWS-specific binding specification
     */
    stack?: DeploymentPendingPreparedStackProfileAwStack | undefined;
};
/**
 * IAM effect. Defaults to Allow.
 */
export declare const DeploymentPendingPreparedStackProfileEffect: {
    readonly Allow: "Allow";
    readonly Deny: "Deny";
};
/**
 * IAM effect. Defaults to Allow.
 */
export type DeploymentPendingPreparedStackProfileEffect = ClosedEnum<typeof DeploymentPendingPreparedStackProfileEffect>;
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackProfileAwGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * AWS-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackProfileAw = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPendingPreparedStackProfileAwBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * IAM effect. Defaults to Allow.
     */
    effect?: DeploymentPendingPreparedStackProfileEffect | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPendingPreparedStackProfileAwGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Azure-specific binding specification
 */
export type DeploymentPendingPreparedStackProfileAzureResource = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Azure-specific binding specification
 */
export type DeploymentPendingPreparedStackProfileAzureStack = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackProfileAzureBinding = {
    /**
     * Azure-specific binding specification
     */
    resource?: DeploymentPendingPreparedStackProfileAzureResource | undefined;
    /**
     * Azure-specific binding specification
     */
    stack?: DeploymentPendingPreparedStackProfileAzureStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackProfileAzureGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * Azure-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackProfileAzure = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPendingPreparedStackProfileAzureBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPendingPreparedStackProfileAzureGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * GCP IAM condition
 */
export type DeploymentPendingPreparedStackProfileConditionResource = {
    expression: string;
    title: string;
};
export type DeploymentPendingPreparedStackProfileResourceConditionUnion = DeploymentPendingPreparedStackProfileConditionResource | any;
/**
 * GCP-specific binding specification
 */
export type DeploymentPendingPreparedStackProfileGcpResource = {
    condition?: DeploymentPendingPreparedStackProfileConditionResource | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * GCP IAM condition
 */
export type DeploymentPendingPreparedStackProfileConditionStack = {
    expression: string;
    title: string;
};
export type DeploymentPendingPreparedStackProfileStackConditionUnion = DeploymentPendingPreparedStackProfileConditionStack | any;
/**
 * GCP-specific binding specification
 */
export type DeploymentPendingPreparedStackProfileGcpStack = {
    condition?: DeploymentPendingPreparedStackProfileConditionStack | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackProfileGcpBinding = {
    /**
     * GCP-specific binding specification
     */
    resource?: DeploymentPendingPreparedStackProfileGcpResource | undefined;
    /**
     * GCP-specific binding specification
     */
    stack?: DeploymentPendingPreparedStackProfileGcpStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackProfileGcpGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * GCP-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackProfileGcp = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPendingPreparedStackProfileGcpBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPendingPreparedStackProfileGcpGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Platform-specific permission configurations
 */
export type DeploymentPendingPreparedStackProfilePlatforms = {
    /**
     * AWS permission configurations
     */
    aws?: Array<DeploymentPendingPreparedStackProfileAw> | null | undefined;
    /**
     * Azure permission configurations
     */
    azure?: Array<DeploymentPendingPreparedStackProfileAzure> | null | undefined;
    /**
     * GCP permission configurations
     */
    gcp?: Array<DeploymentPendingPreparedStackProfileGcp> | null | undefined;
};
/**
 * A permission set that can be applied across different cloud platforms
 */
export type DeploymentPendingPreparedStackProfile = {
    /**
     * Human-readable description of what this permission set allows
     */
    description: string;
    /**
     * Unique identifier for the permission set (e.g., "storage/data-read")
     */
    id: string;
    /**
     * Platform-specific permission configurations
     */
    platforms: DeploymentPendingPreparedStackProfilePlatforms;
};
/**
 * Reference to a permission set - either by name or inline definition
 */
export type DeploymentPendingPreparedStackProfileUnion = DeploymentPendingPreparedStackProfile | string;
/**
 * Combined permissions configuration that contains both profiles and management
 */
export type DeploymentPendingPreparedStackPermissions = {
    /**
     * Management permissions configuration for stack management access
     */
    management?: DeploymentPendingPreparedStackManagement1 | DeploymentPendingPreparedStackManagement2 | DeploymentPendingPreparedStackManagementEnum | undefined;
    /**
     * Permission profiles that define access control for compute services
     *
     * @remarks
     * Key is the profile name, value is the permission configuration
     */
    profiles: {
        [k: string]: {
            [k: string]: Array<DeploymentPendingPreparedStackProfile | 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 DeploymentPendingPreparedStackConfig = {
    /**
     * 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;
};
/**
 * Reference to a resource by its stable id and resource type.
 */
export type DeploymentPendingPreparedStackDependency = {
    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;
};
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export declare const DeploymentPendingPreparedStackLifecycle: {
    readonly Frozen: "frozen";
    readonly Live: "live";
};
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export type DeploymentPendingPreparedStackLifecycle = ClosedEnum<typeof DeploymentPendingPreparedStackLifecycle>;
export type DeploymentPendingPreparedStackResources = {
    /**
     * 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: DeploymentPendingPreparedStackConfig;
    /**
     * Additional dependencies for this resource beyond those defined in the resource itself.
     *
     * @remarks
     * The total dependencies are: resource.get_dependencies() + this list
     */
    dependencies: Array<DeploymentPendingPreparedStackDependency>;
    /**
     * Id of the boolean stack input that decides whether this resource is
     *
     * @remarks
     * created at all. `None` means always create it.
     *
     * Set by `.enabled(input)` in the SDK. Setup emitters render the resource
     * conditionally on the matching template variable, so a deployer who says no
     * never gets the resource, its outputs, or anything derived from it.
     */
    enabledWhen?: string | null | undefined;
    /**
     * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
     */
    lifecycle: DeploymentPendingPreparedStackLifecycle;
    /**
     * Enable remote bindings for this resource (BYOB use case).
     *
     * @remarks
     * When true, binding params are synced to StackState's `remote_binding_params`.
     * Default: false (prevents sensitive data in synced state).
     */
    remoteAccess?: boolean | undefined;
};
/**
 * Represents the target cloud platform.
 */
export declare const DeploymentPendingPreparedStackSupportedPlatform: {
    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 DeploymentPendingPreparedStackSupportedPlatform = ClosedEnum<typeof DeploymentPendingPreparedStackSupportedPlatform>;
/**
 * A bag of resources, unaware of any cloud.
 */
export type DeploymentPendingPreparedStack = {
    /**
     * Unique identifier for the stack
     */
    id: string;
    /**
     * Input definitions required before setup or deployment can proceed.
     */
    inputs?: Array<DeploymentPendingPreparedStackInput> | undefined;
    /**
     * Combined permissions configuration that contains both profiles and management
     */
    permissions?: DeploymentPendingPreparedStackPermissions | undefined;
    /**
     * Map of resource IDs to their configurations and lifecycle settings
     */
    resources: {
        [k: string]: DeploymentPendingPreparedStackResources;
    };
    /**
     * Which platforms this stack supports. When None, all platforms are supported.
     */
    supportedPlatforms?: Array<DeploymentPendingPreparedStackSupportedPlatform> | null | undefined;
};
export type DeploymentPendingPreparedStackUnion = DeploymentPendingPreparedStack | any;
export declare const DeploymentPreparedStackTypeStringList: {
    readonly StringList: "stringList";
};
export type DeploymentPreparedStackTypeStringList = ClosedEnum<typeof DeploymentPreparedStackTypeStringList>;
export type DeploymentPreparedStackDefaultStringList = {
    type: DeploymentPreparedStackTypeStringList;
    /**
     * String list default.
     */
    value: Array<string>;
};
export declare const DeploymentPreparedStackTypeBoolean: {
    readonly Boolean: "boolean";
};
export type DeploymentPreparedStackTypeBoolean = ClosedEnum<typeof DeploymentPreparedStackTypeBoolean>;
export type DeploymentPreparedStackDefaultBoolean = {
    type: DeploymentPreparedStackTypeBoolean;
    /**
     * Boolean default.
     */
    value: boolean;
};
export declare const DeploymentPreparedStackTypeNumber: {
    readonly Number: "number";
};
export type DeploymentPreparedStackTypeNumber = ClosedEnum<typeof DeploymentPreparedStackTypeNumber>;
export type DeploymentPreparedStackDefaultNumber = {
    type: DeploymentPreparedStackTypeNumber;
    /**
     * Number default.
     */
    value: string;
};
export declare const DeploymentPreparedStackTypeString: {
    readonly String: "string";
};
export type DeploymentPreparedStackTypeString = ClosedEnum<typeof DeploymentPreparedStackTypeString>;
export type DeploymentPreparedStackDefaultString = {
    type: DeploymentPreparedStackTypeString;
    /**
     * String default.
     */
    value: string;
};
export type DeploymentPreparedStackDefaultUnion = DeploymentPreparedStackDefaultString | DeploymentPreparedStackDefaultNumber | DeploymentPreparedStackDefaultBoolean | DeploymentPreparedStackDefaultStringList | any;
/**
 * Environment variable handling for a stack input mapping.
 */
export declare const DeploymentPreparedStackTypeEnvEnum: {
    readonly Plain: "plain";
    readonly Secret: "secret";
};
/**
 * Environment variable handling for a stack input mapping.
 */
export type DeploymentPreparedStackTypeEnvEnum = ClosedEnum<typeof DeploymentPreparedStackTypeEnvEnum>;
export type DeploymentPreparedStackTypeUnion = DeploymentPreparedStackTypeEnvEnum | any;
/**
 * How a resolved stack input is injected into runtime environment variables.
 */
export type DeploymentPreparedStackEnv = {
    /**
     * Environment variable name.
     */
    name: string;
    /**
     * Target resource IDs or patterns. None means every env-capable resource.
     */
    targetResources?: Array<string> | null | undefined;
    type?: DeploymentPreparedStackTypeEnvEnum | any | null | undefined;
};
/**
 * Primitive stack input kind.
 */
export declare const DeploymentPreparedStackKind: {
    readonly String: "string";
    readonly Secret: "secret";
    readonly Number: "number";
    readonly Integer: "integer";
    readonly Boolean: "boolean";
    readonly Enum: "enum";
    readonly StringList: "stringList";
};
/**
 * Primitive stack input kind.
 */
export type DeploymentPreparedStackKind = ClosedEnum<typeof DeploymentPreparedStackKind>;
/**
 * Represents the target cloud platform.
 */
export declare const DeploymentPreparedStackPlatform: {
    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 DeploymentPreparedStackPlatform = ClosedEnum<typeof DeploymentPreparedStackPlatform>;
/**
 * Who can provide a stack input value.
 */
export declare const DeploymentPreparedStackProvidedBy: {
    readonly Developer: "developer";
    readonly Deployer: "deployer";
};
/**
 * Who can provide a stack input value.
 */
export type DeploymentPreparedStackProvidedBy = ClosedEnum<typeof DeploymentPreparedStackProvidedBy>;
/**
 * Portable stack input validation constraints.
 */
export type DeploymentPreparedStackValidation = {
    /**
     * Semantic format hint such as url.
     */
    format?: string | null | undefined;
    /**
     * Maximum number.
     */
    max?: string | null | undefined;
    /**
     * Maximum string-list items.
     */
    maxItems?: number | null | undefined;
    /**
     * Maximum string length.
     */
    maxLength?: number | null | undefined;
    /**
     * Minimum number.
     */
    min?: string | null | undefined;
    /**
     * Minimum string-list items.
     */
    minItems?: number | null | undefined;
    /**
     * Minimum string length.
     */
    minLength?: number | null | undefined;
    /**
     * Portable whole-value regex pattern.
     */
    pattern?: string | null | undefined;
    /**
     * Allowed string enum values.
     */
    values?: Array<string> | null | undefined;
};
export type DeploymentPreparedStackValidationUnion = DeploymentPreparedStackValidation | any;
/**
 * Stack input definition serialized into a release stack.
 */
export type DeploymentPreparedStackInput = {
    default?: DeploymentPreparedStackDefaultString | DeploymentPreparedStackDefaultNumber | DeploymentPreparedStackDefaultBoolean | DeploymentPreparedStackDefaultStringList | any | null | undefined;
    /**
     * Human-facing helper text.
     */
    description: string;
    /**
     * Runtime env-var mappings for v1 input resolution.
     */
    env?: Array<DeploymentPreparedStackEnv> | undefined;
    /**
     * Stable input ID used by CLI/API calls.
     */
    id: string;
    /**
     * Primitive stack input kind.
     */
    kind: DeploymentPreparedStackKind;
    /**
     * Human-facing field label.
     */
    label: string;
    /**
     * Example placeholder shown in UI.
     */
    placeholder?: string | null | undefined;
    /**
     * Platforms where this input applies.
     */
    platforms?: Array<DeploymentPreparedStackPlatform> | null | undefined;
    /**
     * Who can provide this value.
     */
    providedBy: Array<DeploymentPreparedStackProvidedBy>;
    /**
     * Whether a resolved value is required before deployment can proceed.
     */
    required: boolean;
    validation?: DeploymentPreparedStackValidation | any | null | undefined;
};
export declare const DeploymentPreparedStackManagementEnum: {
    readonly Auto: "auto";
};
export type DeploymentPreparedStackManagementEnum = ClosedEnum<typeof DeploymentPreparedStackManagementEnum>;
/**
 * AWS-specific binding specification
 */
export type DeploymentPreparedStackOverrideAwResource = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * AWS-specific binding specification
 */
export type DeploymentPreparedStackOverrideAwStack = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackOverrideAwBinding = {
    /**
     * AWS-specific binding specification
     */
    resource?: DeploymentPreparedStackOverrideAwResource | undefined;
    /**
     * AWS-specific binding specification
     */
    stack?: DeploymentPreparedStackOverrideAwStack | undefined;
};
/**
 * IAM effect. Defaults to Allow.
 */
export declare const DeploymentPreparedStackOverrideEffect: {
    readonly Allow: "Allow";
    readonly Deny: "Deny";
};
/**
 * IAM effect. Defaults to Allow.
 */
export type DeploymentPreparedStackOverrideEffect = ClosedEnum<typeof DeploymentPreparedStackOverrideEffect>;
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackOverrideAwGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * AWS-specific platform permission configuration
 */
export type DeploymentPreparedStackOverrideAw = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPreparedStackOverrideAwBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * IAM effect. Defaults to Allow.
     */
    effect?: DeploymentPreparedStackOverrideEffect | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPreparedStackOverrideAwGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Azure-specific binding specification
 */
export type DeploymentPreparedStackOverrideAzureResource = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Azure-specific binding specification
 */
export type DeploymentPreparedStackOverrideAzureStack = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackOverrideAzureBinding = {
    /**
     * Azure-specific binding specification
     */
    resource?: DeploymentPreparedStackOverrideAzureResource | undefined;
    /**
     * Azure-specific binding specification
     */
    stack?: DeploymentPreparedStackOverrideAzureStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackOverrideAzureGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * Azure-specific platform permission configuration
 */
export type DeploymentPreparedStackOverrideAzure = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPreparedStackOverrideAzureBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPreparedStackOverrideAzureGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * GCP IAM condition
 */
export type DeploymentPreparedStackOverrideConditionResource = {
    expression: string;
    title: string;
};
export type DeploymentPreparedStackOverrideResourceConditionUnion = DeploymentPreparedStackOverrideConditionResource | any;
/**
 * GCP-specific binding specification
 */
export type DeploymentPreparedStackOverrideGcpResource = {
    condition?: DeploymentPreparedStackOverrideConditionResource | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * GCP IAM condition
 */
export type DeploymentPreparedStackOverrideConditionStack = {
    expression: string;
    title: string;
};
export type DeploymentPreparedStackOverrideStackConditionUnion = DeploymentPreparedStackOverrideConditionStack | any;
/**
 * GCP-specific binding specification
 */
export type DeploymentPreparedStackOverrideGcpStack = {
    condition?: DeploymentPreparedStackOverrideConditionStack | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackOverrideGcpBinding = {
    /**
     * GCP-specific binding specification
     */
    resource?: DeploymentPreparedStackOverrideGcpResource | undefined;
    /**
     * GCP-specific binding specification
     */
    stack?: DeploymentPreparedStackOverrideGcpStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackOverrideGcpGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * GCP-specific platform permission configuration
 */
export type DeploymentPreparedStackOverrideGcp = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPreparedStackOverrideGcpBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPreparedStackOverrideGcpGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Platform-specific permission configurations
 */
export type DeploymentPreparedStackOverridePlatforms = {
    /**
     * AWS permission configurations
     */
    aws?: Array<DeploymentPreparedStackOverrideAw> | null | undefined;
    /**
     * Azure permission configurations
     */
    azure?: Array<DeploymentPreparedStackOverrideAzure> | null | undefined;
    /**
     * GCP permission configurations
     */
    gcp?: Array<DeploymentPreparedStackOverrideGcp> | null | undefined;
};
/**
 * A permission set that can be applied across different cloud platforms
 */
export type DeploymentPreparedStackOverride = {
    /**
     * Human-readable description of what this permission set allows
     */
    description: string;
    /**
     * Unique identifier for the permission set (e.g., "storage/data-read")
     */
    id: string;
    /**
     * Platform-specific permission configurations
     */
    platforms: DeploymentPreparedStackOverridePlatforms;
};
/**
 * Reference to a permission set - either by name or inline definition
 */
export type DeploymentPreparedStackOverrideUnion = DeploymentPreparedStackOverride | string;
export type DeploymentPreparedStackManagement2 = {
    /**
     * Permission profile that maps resources to permission sets
     *
     * @remarks
     * Key can be "*" for all resources or resource name for specific resource
     */
    override: {
        [k: string]: Array<DeploymentPreparedStackOverride | string>;
    };
};
/**
 * AWS-specific binding specification
 */
export type DeploymentPreparedStackExtendAwResource = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * AWS-specific binding specification
 */
export type DeploymentPreparedStackExtendAwStack = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackExtendAwBinding = {
    /**
     * AWS-specific binding specification
     */
    resource?: DeploymentPreparedStackExtendAwResource | undefined;
    /**
     * AWS-specific binding specification
     */
    stack?: DeploymentPreparedStackExtendAwStack | undefined;
};
/**
 * IAM effect. Defaults to Allow.
 */
export declare const DeploymentPreparedStackExtendEffect: {
    readonly Allow: "Allow";
    readonly Deny: "Deny";
};
/**
 * IAM effect. Defaults to Allow.
 */
export type DeploymentPreparedStackExtendEffect = ClosedEnum<typeof DeploymentPreparedStackExtendEffect>;
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackExtendAwGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * AWS-specific platform permission configuration
 */
export type DeploymentPreparedStackExtendAw = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPreparedStackExtendAwBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * IAM effect. Defaults to Allow.
     */
    effect?: DeploymentPreparedStackExtendEffect | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPreparedStackExtendAwGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Azure-specific binding specification
 */
export type DeploymentPreparedStackExtendAzureResource = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Azure-specific binding specification
 */
export type DeploymentPreparedStackExtendAzureStack = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackExtendAzureBinding = {
    /**
     * Azure-specific binding specification
     */
    resource?: DeploymentPreparedStackExtendAzureResource | undefined;
    /**
     * Azure-specific binding specification
     */
    stack?: DeploymentPreparedStackExtendAzureStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackExtendAzureGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * Azure-specific platform permission configuration
 */
export type DeploymentPreparedStackExtendAzure = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPreparedStackExtendAzureBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPreparedStackExtendAzureGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * GCP IAM condition
 */
export type DeploymentPreparedStackExtendConditionResource = {
    expression: string;
    title: string;
};
export type DeploymentPreparedStackExtendResourceConditionUnion = DeploymentPreparedStackExtendConditionResource | any;
/**
 * GCP-specific binding specification
 */
export type DeploymentPreparedStackExtendGcpResource = {
    condition?: DeploymentPreparedStackExtendConditionResource | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * GCP IAM condition
 */
export type DeploymentPreparedStackExtendConditionStack = {
    expression: string;
    title: string;
};
export type DeploymentPreparedStackExtendStackConditionUnion = DeploymentPreparedStackExtendConditionStack | any;
/**
 * GCP-specific binding specification
 */
export type DeploymentPreparedStackExtendGcpStack = {
    condition?: DeploymentPreparedStackExtendConditionStack | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackExtendGcpBinding = {
    /**
     * GCP-specific binding specification
     */
    resource?: DeploymentPreparedStackExtendGcpResource | undefined;
    /**
     * GCP-specific binding specification
     */
    stack?: DeploymentPreparedStackExtendGcpStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackExtendGcpGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * GCP-specific platform permission configuration
 */
export type DeploymentPreparedStackExtendGcp = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPreparedStackExtendGcpBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPreparedStackExtendGcpGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Platform-specific permission configurations
 */
export type DeploymentPreparedStackExtendPlatforms = {
    /**
     * AWS permission configurations
     */
    aws?: Array<DeploymentPreparedStackExtendAw> | null | undefined;
    /**
     * Azure permission configurations
     */
    azure?: Array<DeploymentPreparedStackExtendAzure> | null | undefined;
    /**
     * GCP permission configurations
     */
    gcp?: Array<DeploymentPreparedStackExtendGcp> | null | undefined;
};
/**
 * A permission set that can be applied across different cloud platforms
 */
export type DeploymentPreparedStackExtend = {
    /**
     * Human-readable description of what this permission set allows
     */
    description: string;
    /**
     * Unique identifier for the permission set (e.g., "storage/data-read")
     */
    id: string;
    /**
     * Platform-specific permission configurations
     */
    platforms: DeploymentPreparedStackExtendPlatforms;
};
/**
 * Reference to a permission set - either by name or inline definition
 */
export type DeploymentPreparedStackExtendUnion = DeploymentPreparedStackExtend | string;
export type DeploymentPreparedStackManagement1 = {
    /**
     * Permission profile that maps resources to permission sets
     *
     * @remarks
     * Key can be "*" for all resources or resource name for specific resource
     */
    extend: {
        [k: string]: Array<DeploymentPreparedStackExtend | string>;
    };
};
/**
 * Management permissions configuration for stack management access
 */
export type DeploymentPreparedStackManagementUnion = DeploymentPreparedStackManagement1 | DeploymentPreparedStackManagement2 | DeploymentPreparedStackManagementEnum;
/**
 * AWS-specific binding specification
 */
export type DeploymentPreparedStackProfileAwResource = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * AWS-specific binding specification
 */
export type DeploymentPreparedStackProfileAwStack = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackProfileAwBinding = {
    /**
     * AWS-specific binding specification
     */
    resource?: DeploymentPreparedStackProfileAwResource | undefined;
    /**
     * AWS-specific binding specification
     */
    stack?: DeploymentPreparedStackProfileAwStack | undefined;
};
/**
 * IAM effect. Defaults to Allow.
 */
export declare const DeploymentPreparedStackProfileEffect: {
    readonly Allow: "Allow";
    readonly Deny: "Deny";
};
/**
 * IAM effect. Defaults to Allow.
 */
export type DeploymentPreparedStackProfileEffect = ClosedEnum<typeof DeploymentPreparedStackProfileEffect>;
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackProfileAwGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * AWS-specific platform permission configuration
 */
export type DeploymentPreparedStackProfileAw = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPreparedStackProfileAwBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * IAM effect. Defaults to Allow.
     */
    effect?: DeploymentPreparedStackProfileEffect | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPreparedStackProfileAwGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Azure-specific binding specification
 */
export type DeploymentPreparedStackProfileAzureResource = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Azure-specific binding specification
 */
export type DeploymentPreparedStackProfileAzureStack = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackProfileAzureBinding = {
    /**
     * Azure-specific binding specification
     */
    resource?: DeploymentPreparedStackProfileAzureResource | undefined;
    /**
     * Azure-specific binding specification
     */
    stack?: DeploymentPreparedStackProfileAzureStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackProfileAzureGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * Azure-specific platform permission configuration
 */
export type DeploymentPreparedStackProfileAzure = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPreparedStackProfileAzureBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPreparedStackProfileAzureGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * GCP IAM condition
 */
export type DeploymentPreparedStackProfileConditionResource = {
    expression: string;
    title: string;
};
export type DeploymentPreparedStackProfileResourceConditionUnion = DeploymentPreparedStackProfileConditionResource | any;
/**
 * GCP-specific binding specification
 */
export type DeploymentPreparedStackProfileGcpResource = {
    condition?: DeploymentPreparedStackProfileConditionResource | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * GCP IAM condition
 */
export type DeploymentPreparedStackProfileConditionStack = {
    expression: string;
    title: string;
};
export type DeploymentPreparedStackProfileStackConditionUnion = DeploymentPreparedStackProfileConditionStack | any;
/**
 * GCP-specific binding specification
 */
export type DeploymentPreparedStackProfileGcpStack = {
    condition?: DeploymentPreparedStackProfileConditionStack | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackProfileGcpBinding = {
    /**
     * GCP-specific binding specification
     */
    resource?: DeploymentPreparedStackProfileGcpResource | undefined;
    /**
     * GCP-specific binding specification
     */
    stack?: DeploymentPreparedStackProfileGcpStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackProfileGcpGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * GCP-specific platform permission configuration
 */
export type DeploymentPreparedStackProfileGcp = {
    /**
     * Generic binding configuration for permissions
     */
    binding: DeploymentPreparedStackProfileGcpBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: DeploymentPreparedStackProfileGcpGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Platform-specific permission configurations
 */
export type DeploymentPreparedStackProfilePlatforms = {
    /**
     * AWS permission configurations
     */
    aws?: Array<DeploymentPreparedStackProfileAw> | null | undefined;
    /**
     * Azure permission configurations
     */
    azure?: Array<DeploymentPreparedStackProfileAzure> | null | undefined;
    /**
     * GCP permission configurations
     */
    gcp?: Array<DeploymentPreparedStackProfileGcp> | null | undefined;
};
/**
 * A permission set that can be applied across different cloud platforms
 */
export type DeploymentPreparedStackProfile = {
    /**
     * Human-readable description of what this permission set allows
     */
    description: string;
    /**
     * Unique identifier for the permission set (e.g., "storage/data-read")
     */
    id: string;
    /**
     * Platform-specific permission configurations
     */
    platforms: DeploymentPreparedStackProfilePlatforms;
};
/**
 * Reference to a permission set - either by name or inline definition
 */
export type DeploymentPreparedStackProfileUnion = DeploymentPreparedStackProfile | string;
/**
 * Combined permissions configuration that contains both profiles and management
 */
export type DeploymentPreparedStackPermissions = {
    /**
     * Management permissions configuration for stack management access
     */
    management?: DeploymentPreparedStackManagement1 | DeploymentPreparedStackManagement2 | DeploymentPreparedStackManagementEnum | undefined;
    /**
     * Permission profiles that define access control for compute services
     *
     * @remarks
     * Key is the profile name, value is the permission configuration
     */
    profiles: {
        [k: string]: {
            [k: string]: Array<DeploymentPreparedStackProfile | 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 DeploymentPreparedStackConfig = {
    /**
     * 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;
};
/**
 * Reference to a resource by its stable id and resource type.
 */
export type DeploymentPreparedStackDependency = {
    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;
};
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export declare const DeploymentPreparedStackLifecycle: {
    readonly Frozen: "frozen";
    readonly Live: "live";
};
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export type DeploymentPreparedStackLifecycle = ClosedEnum<typeof DeploymentPreparedStackLifecycle>;
export type DeploymentPreparedStackResources = {
    /**
     * 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: DeploymentPreparedStackConfig;
    /**
     * Additional dependencies for this resource beyond those defined in the resource itself.
     *
     * @remarks
     * The total dependencies are: resource.get_dependencies() + this list
     */
    dependencies: Array<DeploymentPreparedStackDependency>;
    /**
     * Id of the boolean stack input that decides whether this resource is
     *
     * @remarks
     * created at all. `None` means always create it.
     *
     * Set by `.enabled(input)` in the SDK. Setup emitters render the resource
     * conditionally on the matching template variable, so a deployer who says no
     * never gets the resource, its outputs, or anything derived from it.
     */
    enabledWhen?: string | null | undefined;
    /**
     * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
     */
    lifecycle: DeploymentPreparedStackLifecycle;
    /**
     * Enable remote bindings for this resource (BYOB use case).
     *
     * @remarks
     * When true, binding params are synced to StackState's `remote_binding_params`.
     * Default: false (prevents sensitive data in synced state).
     */
    remoteAccess?: boolean | undefined;
};
/**
 * Represents the target cloud platform.
 */
export declare const DeploymentPreparedStackSupportedPlatform: {
    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 DeploymentPreparedStackSupportedPlatform = ClosedEnum<typeof DeploymentPreparedStackSupportedPlatform>;
/**
 * A bag of resources, unaware of any cloud.
 */
export type DeploymentPreparedStack = {
    /**
     * Unique identifier for the stack
     */
    id: string;
    /**
     * Input definitions required before setup or deployment can proceed.
     */
    inputs?: Array<DeploymentPreparedStackInput> | undefined;
    /**
     * Combined permissions configuration that contains both profiles and management
     */
    permissions?: DeploymentPreparedStackPermissions | undefined;
    /**
     * Map of resource IDs to their configurations and lifecycle settings
     */
    resources: {
        [k: string]: DeploymentPreparedStackResources;
    };
    /**
     * Which platforms this stack supports. When None, all platforms are supported.
     */
    supportedPlatforms?: Array<DeploymentPreparedStackSupportedPlatform> | null | undefined;
};
export type DeploymentPreparedStackUnion = DeploymentPreparedStack | any;
/**
 * One-shot authority for a setup re-import to replace setup-owned resources.
 */
export type DeploymentSetupUpdateAuthorization = {
    /**
     * Frozen resource projection from the last successful deployment.
     */
    baselineFrozenDigest: string;
    /**
     * Unique revision used by persistence layers for compare-and-swap updates.
     */
    nonce: string;
    /**
     * Release whose stack was prepared by setup.
     */
    releaseId: string;
    /**
     * Exact setup artifact revision that authored this authority.
     */
    setupFingerprint: string;
    /**
     * Setup fingerprint contract version.
     */
    setupFingerprintVersion: number;
    /**
     * Stable setup target recorded on the imported deployment.
     */
    setupTarget: string;
    /**
     * Frozen resource projection prepared by the setup re-import.
     */
    targetFrozenDigest: string;
};
export type DeploymentSetupUpdateAuthorizationUnion = DeploymentSetupUpdateAuthorization | any;
/**
 * Runtime metadata for deployment state persistence
 */
export type DeploymentRuntimeMetadata = {
    /**
     * Last generated CLI package revision whose direct setup was applied.
     *
     * @remarks
     * This lets a newer generated CLI refresh setup-owned infrastructure once
     * before handing runtime changes back to the hosted manager.
     */
    directSetupRevision?: string | null | undefined;
    /**
     * Actor that owns structural work during the initial setup phase.
     */
    initialSetupAuthority?: DeploymentInitialSetupAuthority | undefined;
    /**
     * Hash of the environment variables snapshot that was last synced to the vault
     *
     * @remarks
     * Used to avoid redundant sync operations during incremental deployment
     */
    lastSyncedEnvVarsHash?: string | null | undefined;
    /**
     * Exact vault keys owned by the deployment secret synchronizer. This
     *
     * @remarks
     * inventory lets a later snapshot delete removed keys without listing or
     * touching unrelated values in the same vault.
     */
    lastSyncedSecretNames?: Array<string> | undefined;
    pendingPreparedStack?: DeploymentPendingPreparedStack | any | null | undefined;
    /**
     * Canonical resolved answers for inputs that gate Frozen resources,
     *
     * @remarks
     * keyed by input id, recorded when the deployment is created or its
     * setup import registers.
     *
     * A frozen gate's answer is fixed for the deployment's lifetime: the
     * update path refuses input values that conflict with these, and a Live
     * resource sharing such an input resolves the persisted answer forever.
     */
    persistedGateAnswers?: {
        [k: string]: boolean;
    } | undefined;
    preparedStack?: DeploymentPreparedStack | any | null | undefined;
    /**
     * Whether cross-account registry access has been successfully granted.
     *
     * @remarks
     * Set to true after the manager successfully sets the ECR/GAR repo policy
     * for this deployment's target account. Prevents redundant API calls on
     * every reconcile tick.
     */
    registryAccessGranted?: boolean | undefined;
    setupUpdateAuthorization?: DeploymentSetupUpdateAuthorization | any | null | undefined;
};
/**
 * Setup source that imported this deployment
 */
export declare const DeploymentImportSource: {
    readonly Cloudformation: "cloudformation";
    readonly Terraform: "terraform";
    readonly Helm: "helm";
};
/**
 * Setup source that imported this deployment
 */
export type DeploymentImportSource = ClosedEnum<typeof DeploymentImportSource>;
/**
 * Setup method that created the deployment record and owns setup-time resources.
 */
export declare const DeploymentSetupMethod1: {
    readonly Cloudformation: "cloudformation";
    readonly GoogleOauth: "google-oauth";
    readonly Terraform: "terraform";
    readonly Helm: "helm";
    readonly Cli: "cli";
    readonly Manual: "manual";
};
/**
 * Setup method that created the deployment record and owns setup-time resources.
 */
export type DeploymentSetupMethod1 = ClosedEnum<typeof DeploymentSetupMethod1>;
/**
 * Latest error information if the deployment is in a failed state
 */
export type DeploymentError = {
    /**
     * 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;
};
/**
 * Durable progress for deployment updates
 */
export type DeploymentUpdateState = {
    active: DeploymentUpdateOperationSummary | null;
    next: DeploymentUpdateOperationSummary | null;
    latest: DeploymentUpdateOperationSummary | null;
};
export type Deployment = {
    /**
     * Unique identifier for the deployment.
     */
    id: string;
    /**
     * Deployment name.
     */
    name: string;
    /**
     * Public subdomain for auto-generated domains
     */
    publicSubdomain?: string | null | undefined;
    /**
     * 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.
     */
    status: DeploymentStatus;
    /**
     * Unique identifier for the project.
     */
    projectId: string;
    /**
     * Target platform for the deployment
     */
    platform: DeploymentPlatform;
    /**
     * Underlying cloud platform for Kubernetes deployments.
     */
    basePlatform?: DeploymentBasePlatform | null | undefined;
    /**
     * Cloud region or location for the deployment.
     */
    region?: string | null | undefined;
    /**
     * DeploymentState protocol version owned by the runtime/manager
     */
    deploymentProtocolVersion: number;
    /**
     * ID of deployment group this deployment belongs to
     */
    deploymentGroupId: string;
    /**
     * Operational purpose of this deployment within its customer environment.
     */
    purpose: DeploymentPurpose;
    /**
     * Cloud environment information
     */
    environmentInfo?: DeploymentEnvironmentInfoGcp | DeploymentEnvironmentInfoAzure | DeploymentEnvironmentInfoLocal | DeploymentEnvironmentInfoAws | DeploymentEnvironmentInfoTest | any | null | undefined;
    /**
     * User-provided configuration (network, deployment model, approvals)
     */
    stackSettings: DeploymentStackSettings;
    /**
     * State of infrastructure components managed by this deployment
     */
    stackState?: DeploymentStackState | null | undefined;
    /**
     * Runtime metadata for deployment state persistence
     */
    runtimeMetadata?: DeploymentRuntimeMetadata | null | undefined;
    /**
     * ID of the currently deployed release (actual state)
     */
    currentReleaseId?: string | null | undefined;
    /**
     * ID of the desired release for deployment/update (desired state)
     */
    desiredReleaseId?: string | null | undefined;
    /**
     * ID of the pinned release
     */
    pinnedReleaseId?: string | null | undefined;
    releaseChannel: string;
    /**
     * Setup source that imported this deployment
     */
    importSource?: DeploymentImportSource | null | undefined;
    /**
     * Setup method that created the deployment record and owns setup-time resources.
     */
    setupMethod?: DeploymentSetupMethod1 | null | undefined;
    /**
     * Setup method metadata needed to guide privileged teardown.
     */
    setupMetadata?: {
        [k: string]: any | null;
    } | null | undefined;
    /**
     * Imported setup target for compatibility checks
     */
    setupTarget?: string | null | undefined;
    /**
     * Imported setup compatibility fingerprint
     */
    setupFingerprint?: string | null | undefined;
    /**
     * Imported setup fingerprint algorithm version
     */
    setupFingerprintVersion?: number | null | undefined;
    /**
     * Display-only scope reported by the Operator manifest
     */
    operatorScope?: string | null | undefined;
    /**
     * Display-only permission tier reported by the Operator manifest
     */
    operatorPermission?: string | null | undefined;
    /**
     * Version reported by the Operator
     */
    operatorVersion?: string | null | undefined;
    /**
     * Capability state reported by the Operator
     */
    capabilities?: Array<OperatorCapabilityReport> | null | undefined;
    /**
     * Enabled-plugin-bundle-set hash the Operator reports having loaded
     */
    observedOperationsBundleHash?: string | null | undefined;
    /**
     * Operations the Operator reports as currently loaded
     */
    observedOperations?: Array<ReportedOperation> | null | undefined;
    /**
     * Whether a retry has been requested for a failed deployment
     */
    retryRequested: boolean;
    /**
     * Timestamp of the last received heartbeat from the deployment
     */
    lastHeartbeatAt?: Date | null | undefined;
    /**
     * Latest error information if the deployment is in a failed state
     */
    error?: DeploymentError | null | undefined;
    /**
     * Durable progress for deployment updates
     */
    updateState?: DeploymentUpdateState | undefined;
    createdAt: Date;
    updatedAt: Date;
    managerId: string;
    /**
     * Unique identifier for the workspace.
     */
    workspaceId: 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 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 DeploymentExternalBindings$inboundSchema: z.ZodType<DeploymentExternalBindings, unknown>;
export declare function deploymentExternalBindingsFromJSON(jsonString: string): SafeParseResult<DeploymentExternalBindings, SDKValidationError>;
/** @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 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 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>;
/** @internal */
export declare const DeploymentPendingPreparedStackTypeEnvEnum$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackTypeEnvEnum>;
/** @internal */
export declare const DeploymentPendingPreparedStackTypeUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackTypeUnion, unknown>;
export declare function deploymentPendingPreparedStackTypeUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackTypeUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackEnv$inboundSchema: z.ZodType<DeploymentPendingPreparedStackEnv, unknown>;
export declare function deploymentPendingPreparedStackEnvFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackEnv, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackKind$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackKind>;
/** @internal */
export declare const DeploymentPendingPreparedStackPlatform$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackPlatform>;
/** @internal */
export declare const DeploymentPendingPreparedStackProvidedBy$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackProvidedBy>;
/** @internal */
export declare const DeploymentPendingPreparedStackValidation$inboundSchema: z.ZodType<DeploymentPendingPreparedStackValidation, unknown>;
export declare function deploymentPendingPreparedStackValidationFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackValidation, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackValidationUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackValidationUnion, unknown>;
export declare function deploymentPendingPreparedStackValidationUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackValidationUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackInput$inboundSchema: z.ZodType<DeploymentPendingPreparedStackInput, unknown>;
export declare function deploymentPendingPreparedStackInputFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackInput, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackManagementEnum$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackManagementEnum>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideAwResource$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideAwResource, unknown>;
export declare function deploymentPendingPreparedStackOverrideAwResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideAwResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideAwStack$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideAwStack, unknown>;
export declare function deploymentPendingPreparedStackOverrideAwStackFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideAwStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideAwBinding$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideAwBinding, unknown>;
export declare function deploymentPendingPreparedStackOverrideAwBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideAwBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideEffect$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackOverrideEffect>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideAwGrant$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideAwGrant, unknown>;
export declare function deploymentPendingPreparedStackOverrideAwGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideAwGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideAw$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideAw, unknown>;
export declare function deploymentPendingPreparedStackOverrideAwFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideAw, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideAzureResource$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideAzureResource, unknown>;
export declare function deploymentPendingPreparedStackOverrideAzureResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideAzureResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideAzureStack$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideAzureStack, unknown>;
export declare function deploymentPendingPreparedStackOverrideAzureStackFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideAzureStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideAzureBinding$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideAzureBinding, unknown>;
export declare function deploymentPendingPreparedStackOverrideAzureBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideAzureBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideAzureGrant$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideAzureGrant, unknown>;
export declare function deploymentPendingPreparedStackOverrideAzureGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideAzureGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideAzure$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideAzure, unknown>;
export declare function deploymentPendingPreparedStackOverrideAzureFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideAzure, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideConditionResource$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideConditionResource, unknown>;
export declare function deploymentPendingPreparedStackOverrideConditionResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideConditionResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideResourceConditionUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideResourceConditionUnion, unknown>;
export declare function deploymentPendingPreparedStackOverrideResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideResourceConditionUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideGcpResource$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideGcpResource, unknown>;
export declare function deploymentPendingPreparedStackOverrideGcpResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideGcpResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideConditionStack$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideConditionStack, unknown>;
export declare function deploymentPendingPreparedStackOverrideConditionStackFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideConditionStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideStackConditionUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideStackConditionUnion, unknown>;
export declare function deploymentPendingPreparedStackOverrideStackConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideStackConditionUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideGcpStack$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideGcpStack, unknown>;
export declare function deploymentPendingPreparedStackOverrideGcpStackFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideGcpStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideGcpBinding$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideGcpBinding, unknown>;
export declare function deploymentPendingPreparedStackOverrideGcpBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideGcpBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideGcpGrant$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideGcpGrant, unknown>;
export declare function deploymentPendingPreparedStackOverrideGcpGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideGcpGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideGcp$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideGcp, unknown>;
export declare function deploymentPendingPreparedStackOverrideGcpFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideGcp, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverridePlatforms$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverridePlatforms, unknown>;
export declare function deploymentPendingPreparedStackOverridePlatformsFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverridePlatforms, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverride$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverride, unknown>;
export declare function deploymentPendingPreparedStackOverrideFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverride, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackOverrideUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackOverrideUnion, unknown>;
export declare function deploymentPendingPreparedStackOverrideUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackOverrideUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackManagement2$inboundSchema: z.ZodType<DeploymentPendingPreparedStackManagement2, unknown>;
export declare function deploymentPendingPreparedStackManagement2FromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackManagement2, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendAwResource$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendAwResource, unknown>;
export declare function deploymentPendingPreparedStackExtendAwResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendAwResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendAwStack$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendAwStack, unknown>;
export declare function deploymentPendingPreparedStackExtendAwStackFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendAwStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendAwBinding$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendAwBinding, unknown>;
export declare function deploymentPendingPreparedStackExtendAwBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendAwBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendEffect$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackExtendEffect>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendAwGrant$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendAwGrant, unknown>;
export declare function deploymentPendingPreparedStackExtendAwGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendAwGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendAw$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendAw, unknown>;
export declare function deploymentPendingPreparedStackExtendAwFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendAw, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendAzureResource$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendAzureResource, unknown>;
export declare function deploymentPendingPreparedStackExtendAzureResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendAzureResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendAzureStack$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendAzureStack, unknown>;
export declare function deploymentPendingPreparedStackExtendAzureStackFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendAzureStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendAzureBinding$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendAzureBinding, unknown>;
export declare function deploymentPendingPreparedStackExtendAzureBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendAzureBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendAzureGrant$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendAzureGrant, unknown>;
export declare function deploymentPendingPreparedStackExtendAzureGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendAzureGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendAzure$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendAzure, unknown>;
export declare function deploymentPendingPreparedStackExtendAzureFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendAzure, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendConditionResource$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendConditionResource, unknown>;
export declare function deploymentPendingPreparedStackExtendConditionResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendConditionResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendResourceConditionUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendResourceConditionUnion, unknown>;
export declare function deploymentPendingPreparedStackExtendResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendResourceConditionUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendGcpResource$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendGcpResource, unknown>;
export declare function deploymentPendingPreparedStackExtendGcpResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendGcpResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendConditionStack$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendConditionStack, unknown>;
export declare function deploymentPendingPreparedStackExtendConditionStackFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendConditionStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendStackConditionUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendStackConditionUnion, unknown>;
export declare function deploymentPendingPreparedStackExtendStackConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendStackConditionUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendGcpStack$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendGcpStack, unknown>;
export declare function deploymentPendingPreparedStackExtendGcpStackFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendGcpStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendGcpBinding$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendGcpBinding, unknown>;
export declare function deploymentPendingPreparedStackExtendGcpBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendGcpBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendGcpGrant$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendGcpGrant, unknown>;
export declare function deploymentPendingPreparedStackExtendGcpGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendGcpGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendGcp$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendGcp, unknown>;
export declare function deploymentPendingPreparedStackExtendGcpFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendGcp, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendPlatforms$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendPlatforms, unknown>;
export declare function deploymentPendingPreparedStackExtendPlatformsFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendPlatforms, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtend$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtend, unknown>;
export declare function deploymentPendingPreparedStackExtendFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtend, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackExtendUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackExtendUnion, unknown>;
export declare function deploymentPendingPreparedStackExtendUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackExtendUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackManagement1$inboundSchema: z.ZodType<DeploymentPendingPreparedStackManagement1, unknown>;
export declare function deploymentPendingPreparedStackManagement1FromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackManagement1, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackManagementUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackManagementUnion, unknown>;
export declare function deploymentPendingPreparedStackManagementUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackManagementUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileAwResource$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileAwResource, unknown>;
export declare function deploymentPendingPreparedStackProfileAwResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileAwResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileAwStack$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileAwStack, unknown>;
export declare function deploymentPendingPreparedStackProfileAwStackFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileAwStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileAwBinding$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileAwBinding, unknown>;
export declare function deploymentPendingPreparedStackProfileAwBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileAwBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileEffect$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackProfileEffect>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileAwGrant$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileAwGrant, unknown>;
export declare function deploymentPendingPreparedStackProfileAwGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileAwGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileAw$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileAw, unknown>;
export declare function deploymentPendingPreparedStackProfileAwFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileAw, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileAzureResource$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileAzureResource, unknown>;
export declare function deploymentPendingPreparedStackProfileAzureResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileAzureResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileAzureStack$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileAzureStack, unknown>;
export declare function deploymentPendingPreparedStackProfileAzureStackFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileAzureStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileAzureBinding$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileAzureBinding, unknown>;
export declare function deploymentPendingPreparedStackProfileAzureBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileAzureBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileAzureGrant$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileAzureGrant, unknown>;
export declare function deploymentPendingPreparedStackProfileAzureGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileAzureGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileAzure$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileAzure, unknown>;
export declare function deploymentPendingPreparedStackProfileAzureFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileAzure, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileConditionResource$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileConditionResource, unknown>;
export declare function deploymentPendingPreparedStackProfileConditionResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileConditionResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileResourceConditionUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileResourceConditionUnion, unknown>;
export declare function deploymentPendingPreparedStackProfileResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileResourceConditionUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileGcpResource$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileGcpResource, unknown>;
export declare function deploymentPendingPreparedStackProfileGcpResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileGcpResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileConditionStack$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileConditionStack, unknown>;
export declare function deploymentPendingPreparedStackProfileConditionStackFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileConditionStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileStackConditionUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileStackConditionUnion, unknown>;
export declare function deploymentPendingPreparedStackProfileStackConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileStackConditionUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileGcpStack$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileGcpStack, unknown>;
export declare function deploymentPendingPreparedStackProfileGcpStackFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileGcpStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileGcpBinding$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileGcpBinding, unknown>;
export declare function deploymentPendingPreparedStackProfileGcpBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileGcpBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileGcpGrant$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileGcpGrant, unknown>;
export declare function deploymentPendingPreparedStackProfileGcpGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileGcpGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileGcp$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileGcp, unknown>;
export declare function deploymentPendingPreparedStackProfileGcpFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileGcp, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfilePlatforms$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfilePlatforms, unknown>;
export declare function deploymentPendingPreparedStackProfilePlatformsFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfilePlatforms, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfile$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfile, unknown>;
export declare function deploymentPendingPreparedStackProfileFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfile, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackProfileUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackProfileUnion, unknown>;
export declare function deploymentPendingPreparedStackProfileUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackProfileUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackPermissions$inboundSchema: z.ZodType<DeploymentPendingPreparedStackPermissions, unknown>;
export declare function deploymentPendingPreparedStackPermissionsFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackPermissions, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackConfig$inboundSchema: z.ZodType<DeploymentPendingPreparedStackConfig, unknown>;
export declare function deploymentPendingPreparedStackConfigFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackConfig, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackDependency$inboundSchema: z.ZodType<DeploymentPendingPreparedStackDependency, unknown>;
export declare function deploymentPendingPreparedStackDependencyFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackDependency, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackLifecycle$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackLifecycle>;
/** @internal */
export declare const DeploymentPendingPreparedStackResources$inboundSchema: z.ZodType<DeploymentPendingPreparedStackResources, unknown>;
export declare function deploymentPendingPreparedStackResourcesFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackResources, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackSupportedPlatform$inboundSchema: z.ZodEnum<typeof DeploymentPendingPreparedStackSupportedPlatform>;
/** @internal */
export declare const DeploymentPendingPreparedStack$inboundSchema: z.ZodType<DeploymentPendingPreparedStack, unknown>;
export declare function deploymentPendingPreparedStackFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPendingPreparedStackUnion$inboundSchema: z.ZodType<DeploymentPendingPreparedStackUnion, unknown>;
export declare function deploymentPendingPreparedStackUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPendingPreparedStackUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackTypeStringList$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackTypeStringList>;
/** @internal */
export declare const DeploymentPreparedStackDefaultStringList$inboundSchema: z.ZodType<DeploymentPreparedStackDefaultStringList, unknown>;
export declare function deploymentPreparedStackDefaultStringListFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackDefaultStringList, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackTypeBoolean$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackTypeBoolean>;
/** @internal */
export declare const DeploymentPreparedStackDefaultBoolean$inboundSchema: z.ZodType<DeploymentPreparedStackDefaultBoolean, unknown>;
export declare function deploymentPreparedStackDefaultBooleanFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackDefaultBoolean, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackTypeNumber$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackTypeNumber>;
/** @internal */
export declare const DeploymentPreparedStackDefaultNumber$inboundSchema: z.ZodType<DeploymentPreparedStackDefaultNumber, unknown>;
export declare function deploymentPreparedStackDefaultNumberFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackDefaultNumber, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackTypeString$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackTypeString>;
/** @internal */
export declare const DeploymentPreparedStackDefaultString$inboundSchema: z.ZodType<DeploymentPreparedStackDefaultString, unknown>;
export declare function deploymentPreparedStackDefaultStringFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackDefaultString, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackDefaultUnion$inboundSchema: z.ZodType<DeploymentPreparedStackDefaultUnion, unknown>;
export declare function deploymentPreparedStackDefaultUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackDefaultUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackTypeEnvEnum$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackTypeEnvEnum>;
/** @internal */
export declare const DeploymentPreparedStackTypeUnion$inboundSchema: z.ZodType<DeploymentPreparedStackTypeUnion, unknown>;
export declare function deploymentPreparedStackTypeUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackTypeUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackEnv$inboundSchema: z.ZodType<DeploymentPreparedStackEnv, unknown>;
export declare function deploymentPreparedStackEnvFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackEnv, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackKind$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackKind>;
/** @internal */
export declare const DeploymentPreparedStackPlatform$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackPlatform>;
/** @internal */
export declare const DeploymentPreparedStackProvidedBy$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackProvidedBy>;
/** @internal */
export declare const DeploymentPreparedStackValidation$inboundSchema: z.ZodType<DeploymentPreparedStackValidation, unknown>;
export declare function deploymentPreparedStackValidationFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackValidation, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackValidationUnion$inboundSchema: z.ZodType<DeploymentPreparedStackValidationUnion, unknown>;
export declare function deploymentPreparedStackValidationUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackValidationUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackInput$inboundSchema: z.ZodType<DeploymentPreparedStackInput, unknown>;
export declare function deploymentPreparedStackInputFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackInput, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackManagementEnum$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackManagementEnum>;
/** @internal */
export declare const DeploymentPreparedStackOverrideAwResource$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideAwResource, unknown>;
export declare function deploymentPreparedStackOverrideAwResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideAwResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideAwStack$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideAwStack, unknown>;
export declare function deploymentPreparedStackOverrideAwStackFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideAwStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideAwBinding$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideAwBinding, unknown>;
export declare function deploymentPreparedStackOverrideAwBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideAwBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideEffect$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackOverrideEffect>;
/** @internal */
export declare const DeploymentPreparedStackOverrideAwGrant$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideAwGrant, unknown>;
export declare function deploymentPreparedStackOverrideAwGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideAwGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideAw$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideAw, unknown>;
export declare function deploymentPreparedStackOverrideAwFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideAw, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideAzureResource$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideAzureResource, unknown>;
export declare function deploymentPreparedStackOverrideAzureResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideAzureResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideAzureStack$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideAzureStack, unknown>;
export declare function deploymentPreparedStackOverrideAzureStackFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideAzureStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideAzureBinding$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideAzureBinding, unknown>;
export declare function deploymentPreparedStackOverrideAzureBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideAzureBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideAzureGrant$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideAzureGrant, unknown>;
export declare function deploymentPreparedStackOverrideAzureGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideAzureGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideAzure$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideAzure, unknown>;
export declare function deploymentPreparedStackOverrideAzureFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideAzure, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideConditionResource$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideConditionResource, unknown>;
export declare function deploymentPreparedStackOverrideConditionResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideConditionResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideResourceConditionUnion$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideResourceConditionUnion, unknown>;
export declare function deploymentPreparedStackOverrideResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideResourceConditionUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideGcpResource$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideGcpResource, unknown>;
export declare function deploymentPreparedStackOverrideGcpResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideGcpResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideConditionStack$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideConditionStack, unknown>;
export declare function deploymentPreparedStackOverrideConditionStackFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideConditionStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideStackConditionUnion$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideStackConditionUnion, unknown>;
export declare function deploymentPreparedStackOverrideStackConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideStackConditionUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideGcpStack$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideGcpStack, unknown>;
export declare function deploymentPreparedStackOverrideGcpStackFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideGcpStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideGcpBinding$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideGcpBinding, unknown>;
export declare function deploymentPreparedStackOverrideGcpBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideGcpBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideGcpGrant$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideGcpGrant, unknown>;
export declare function deploymentPreparedStackOverrideGcpGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideGcpGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideGcp$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideGcp, unknown>;
export declare function deploymentPreparedStackOverrideGcpFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideGcp, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverridePlatforms$inboundSchema: z.ZodType<DeploymentPreparedStackOverridePlatforms, unknown>;
export declare function deploymentPreparedStackOverridePlatformsFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverridePlatforms, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverride$inboundSchema: z.ZodType<DeploymentPreparedStackOverride, unknown>;
export declare function deploymentPreparedStackOverrideFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverride, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackOverrideUnion$inboundSchema: z.ZodType<DeploymentPreparedStackOverrideUnion, unknown>;
export declare function deploymentPreparedStackOverrideUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackOverrideUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackManagement2$inboundSchema: z.ZodType<DeploymentPreparedStackManagement2, unknown>;
export declare function deploymentPreparedStackManagement2FromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackManagement2, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendAwResource$inboundSchema: z.ZodType<DeploymentPreparedStackExtendAwResource, unknown>;
export declare function deploymentPreparedStackExtendAwResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendAwResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendAwStack$inboundSchema: z.ZodType<DeploymentPreparedStackExtendAwStack, unknown>;
export declare function deploymentPreparedStackExtendAwStackFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendAwStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendAwBinding$inboundSchema: z.ZodType<DeploymentPreparedStackExtendAwBinding, unknown>;
export declare function deploymentPreparedStackExtendAwBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendAwBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendEffect$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackExtendEffect>;
/** @internal */
export declare const DeploymentPreparedStackExtendAwGrant$inboundSchema: z.ZodType<DeploymentPreparedStackExtendAwGrant, unknown>;
export declare function deploymentPreparedStackExtendAwGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendAwGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendAw$inboundSchema: z.ZodType<DeploymentPreparedStackExtendAw, unknown>;
export declare function deploymentPreparedStackExtendAwFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendAw, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendAzureResource$inboundSchema: z.ZodType<DeploymentPreparedStackExtendAzureResource, unknown>;
export declare function deploymentPreparedStackExtendAzureResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendAzureResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendAzureStack$inboundSchema: z.ZodType<DeploymentPreparedStackExtendAzureStack, unknown>;
export declare function deploymentPreparedStackExtendAzureStackFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendAzureStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendAzureBinding$inboundSchema: z.ZodType<DeploymentPreparedStackExtendAzureBinding, unknown>;
export declare function deploymentPreparedStackExtendAzureBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendAzureBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendAzureGrant$inboundSchema: z.ZodType<DeploymentPreparedStackExtendAzureGrant, unknown>;
export declare function deploymentPreparedStackExtendAzureGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendAzureGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendAzure$inboundSchema: z.ZodType<DeploymentPreparedStackExtendAzure, unknown>;
export declare function deploymentPreparedStackExtendAzureFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendAzure, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendConditionResource$inboundSchema: z.ZodType<DeploymentPreparedStackExtendConditionResource, unknown>;
export declare function deploymentPreparedStackExtendConditionResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendConditionResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendResourceConditionUnion$inboundSchema: z.ZodType<DeploymentPreparedStackExtendResourceConditionUnion, unknown>;
export declare function deploymentPreparedStackExtendResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendResourceConditionUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendGcpResource$inboundSchema: z.ZodType<DeploymentPreparedStackExtendGcpResource, unknown>;
export declare function deploymentPreparedStackExtendGcpResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendGcpResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendConditionStack$inboundSchema: z.ZodType<DeploymentPreparedStackExtendConditionStack, unknown>;
export declare function deploymentPreparedStackExtendConditionStackFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendConditionStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendStackConditionUnion$inboundSchema: z.ZodType<DeploymentPreparedStackExtendStackConditionUnion, unknown>;
export declare function deploymentPreparedStackExtendStackConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendStackConditionUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendGcpStack$inboundSchema: z.ZodType<DeploymentPreparedStackExtendGcpStack, unknown>;
export declare function deploymentPreparedStackExtendGcpStackFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendGcpStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendGcpBinding$inboundSchema: z.ZodType<DeploymentPreparedStackExtendGcpBinding, unknown>;
export declare function deploymentPreparedStackExtendGcpBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendGcpBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendGcpGrant$inboundSchema: z.ZodType<DeploymentPreparedStackExtendGcpGrant, unknown>;
export declare function deploymentPreparedStackExtendGcpGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendGcpGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendGcp$inboundSchema: z.ZodType<DeploymentPreparedStackExtendGcp, unknown>;
export declare function deploymentPreparedStackExtendGcpFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendGcp, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendPlatforms$inboundSchema: z.ZodType<DeploymentPreparedStackExtendPlatforms, unknown>;
export declare function deploymentPreparedStackExtendPlatformsFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendPlatforms, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtend$inboundSchema: z.ZodType<DeploymentPreparedStackExtend, unknown>;
export declare function deploymentPreparedStackExtendFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtend, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackExtendUnion$inboundSchema: z.ZodType<DeploymentPreparedStackExtendUnion, unknown>;
export declare function deploymentPreparedStackExtendUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackExtendUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackManagement1$inboundSchema: z.ZodType<DeploymentPreparedStackManagement1, unknown>;
export declare function deploymentPreparedStackManagement1FromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackManagement1, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackManagementUnion$inboundSchema: z.ZodType<DeploymentPreparedStackManagementUnion, unknown>;
export declare function deploymentPreparedStackManagementUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackManagementUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileAwResource$inboundSchema: z.ZodType<DeploymentPreparedStackProfileAwResource, unknown>;
export declare function deploymentPreparedStackProfileAwResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileAwResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileAwStack$inboundSchema: z.ZodType<DeploymentPreparedStackProfileAwStack, unknown>;
export declare function deploymentPreparedStackProfileAwStackFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileAwStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileAwBinding$inboundSchema: z.ZodType<DeploymentPreparedStackProfileAwBinding, unknown>;
export declare function deploymentPreparedStackProfileAwBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileAwBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileEffect$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackProfileEffect>;
/** @internal */
export declare const DeploymentPreparedStackProfileAwGrant$inboundSchema: z.ZodType<DeploymentPreparedStackProfileAwGrant, unknown>;
export declare function deploymentPreparedStackProfileAwGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileAwGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileAw$inboundSchema: z.ZodType<DeploymentPreparedStackProfileAw, unknown>;
export declare function deploymentPreparedStackProfileAwFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileAw, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileAzureResource$inboundSchema: z.ZodType<DeploymentPreparedStackProfileAzureResource, unknown>;
export declare function deploymentPreparedStackProfileAzureResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileAzureResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileAzureStack$inboundSchema: z.ZodType<DeploymentPreparedStackProfileAzureStack, unknown>;
export declare function deploymentPreparedStackProfileAzureStackFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileAzureStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileAzureBinding$inboundSchema: z.ZodType<DeploymentPreparedStackProfileAzureBinding, unknown>;
export declare function deploymentPreparedStackProfileAzureBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileAzureBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileAzureGrant$inboundSchema: z.ZodType<DeploymentPreparedStackProfileAzureGrant, unknown>;
export declare function deploymentPreparedStackProfileAzureGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileAzureGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileAzure$inboundSchema: z.ZodType<DeploymentPreparedStackProfileAzure, unknown>;
export declare function deploymentPreparedStackProfileAzureFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileAzure, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileConditionResource$inboundSchema: z.ZodType<DeploymentPreparedStackProfileConditionResource, unknown>;
export declare function deploymentPreparedStackProfileConditionResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileConditionResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileResourceConditionUnion$inboundSchema: z.ZodType<DeploymentPreparedStackProfileResourceConditionUnion, unknown>;
export declare function deploymentPreparedStackProfileResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileResourceConditionUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileGcpResource$inboundSchema: z.ZodType<DeploymentPreparedStackProfileGcpResource, unknown>;
export declare function deploymentPreparedStackProfileGcpResourceFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileGcpResource, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileConditionStack$inboundSchema: z.ZodType<DeploymentPreparedStackProfileConditionStack, unknown>;
export declare function deploymentPreparedStackProfileConditionStackFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileConditionStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileStackConditionUnion$inboundSchema: z.ZodType<DeploymentPreparedStackProfileStackConditionUnion, unknown>;
export declare function deploymentPreparedStackProfileStackConditionUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileStackConditionUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileGcpStack$inboundSchema: z.ZodType<DeploymentPreparedStackProfileGcpStack, unknown>;
export declare function deploymentPreparedStackProfileGcpStackFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileGcpStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileGcpBinding$inboundSchema: z.ZodType<DeploymentPreparedStackProfileGcpBinding, unknown>;
export declare function deploymentPreparedStackProfileGcpBindingFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileGcpBinding, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileGcpGrant$inboundSchema: z.ZodType<DeploymentPreparedStackProfileGcpGrant, unknown>;
export declare function deploymentPreparedStackProfileGcpGrantFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileGcpGrant, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileGcp$inboundSchema: z.ZodType<DeploymentPreparedStackProfileGcp, unknown>;
export declare function deploymentPreparedStackProfileGcpFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileGcp, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfilePlatforms$inboundSchema: z.ZodType<DeploymentPreparedStackProfilePlatforms, unknown>;
export declare function deploymentPreparedStackProfilePlatformsFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfilePlatforms, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfile$inboundSchema: z.ZodType<DeploymentPreparedStackProfile, unknown>;
export declare function deploymentPreparedStackProfileFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfile, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackProfileUnion$inboundSchema: z.ZodType<DeploymentPreparedStackProfileUnion, unknown>;
export declare function deploymentPreparedStackProfileUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackProfileUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackPermissions$inboundSchema: z.ZodType<DeploymentPreparedStackPermissions, unknown>;
export declare function deploymentPreparedStackPermissionsFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackPermissions, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackConfig$inboundSchema: z.ZodType<DeploymentPreparedStackConfig, unknown>;
export declare function deploymentPreparedStackConfigFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackConfig, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackDependency$inboundSchema: z.ZodType<DeploymentPreparedStackDependency, unknown>;
export declare function deploymentPreparedStackDependencyFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackDependency, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackLifecycle$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackLifecycle>;
/** @internal */
export declare const DeploymentPreparedStackResources$inboundSchema: z.ZodType<DeploymentPreparedStackResources, unknown>;
export declare function deploymentPreparedStackResourcesFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackResources, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackSupportedPlatform$inboundSchema: z.ZodEnum<typeof DeploymentPreparedStackSupportedPlatform>;
/** @internal */
export declare const DeploymentPreparedStack$inboundSchema: z.ZodType<DeploymentPreparedStack, unknown>;
export declare function deploymentPreparedStackFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStack, SDKValidationError>;
/** @internal */
export declare const DeploymentPreparedStackUnion$inboundSchema: z.ZodType<DeploymentPreparedStackUnion, unknown>;
export declare function deploymentPreparedStackUnionFromJSON(jsonString: string): SafeParseResult<DeploymentPreparedStackUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentSetupUpdateAuthorization$inboundSchema: z.ZodType<DeploymentSetupUpdateAuthorization, unknown>;
export declare function deploymentSetupUpdateAuthorizationFromJSON(jsonString: string): SafeParseResult<DeploymentSetupUpdateAuthorization, SDKValidationError>;
/** @internal */
export declare const DeploymentSetupUpdateAuthorizationUnion$inboundSchema: z.ZodType<DeploymentSetupUpdateAuthorizationUnion, unknown>;
export declare function deploymentSetupUpdateAuthorizationUnionFromJSON(jsonString: string): SafeParseResult<DeploymentSetupUpdateAuthorizationUnion, SDKValidationError>;
/** @internal */
export declare const DeploymentRuntimeMetadata$inboundSchema: z.ZodType<DeploymentRuntimeMetadata, unknown>;
export declare function deploymentRuntimeMetadataFromJSON(jsonString: string): SafeParseResult<DeploymentRuntimeMetadata, SDKValidationError>;
/** @internal */
export declare const DeploymentImportSource$inboundSchema: z.ZodEnum<typeof DeploymentImportSource>;
/** @internal */
export declare const DeploymentSetupMethod1$inboundSchema: z.ZodEnum<typeof DeploymentSetupMethod1>;
/** @internal */
export declare const DeploymentError$inboundSchema: z.ZodType<DeploymentError, unknown>;
export declare function deploymentErrorFromJSON(jsonString: string): SafeParseResult<DeploymentError, SDKValidationError>;
/** @internal */
export declare const DeploymentUpdateState$inboundSchema: z.ZodType<DeploymentUpdateState, unknown>;
export declare function deploymentUpdateStateFromJSON(jsonString: string): SafeParseResult<DeploymentUpdateState, SDKValidationError>;
/** @internal */
export declare const Deployment$inboundSchema: z.ZodType<Deployment, unknown>;
export declare function deploymentFromJSON(jsonString: string): SafeParseResult<Deployment, SDKValidationError>;
//# sourceMappingURL=deployment.d.ts.map