@alienplatform/platform-api 3.3.32 → 3.3.33

package/esm/models/targetdeploymentvolumerestore.d.ts

@@ -0,0 +1,2041 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ExternalBindingUnion } from "./externalbindingunion.js";
+/**
+ * Represents the target cloud platform.
+ */
+export declare const TargetDeploymentBasePlatformEnum: {
+    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 TargetDeploymentBasePlatformEnum = ClosedEnum<typeof TargetDeploymentBasePlatformEnum>;
+export type TargetDeploymentBasePlatformUnion = TargetDeploymentBasePlatformEnum | string;
+/**
+ * Configuration for a single container worker cluster.
+ *
+ * @remarks
+ *
+ * Contains the cluster ID and management token needed to interact with
+ * the managed container control plane API for container operations.
+ */
+export type TargetDeploymentClusters = {
+    /**
+     * Cluster ID (deterministic: workspace/project/deployment/resourceid)
+     */
+    clusterId: string;
+    /**
+     * Management token for API access (hm_...)
+     *
+     * @remarks
+     * Used by alien-deployment controllers to create/update containers
+     */
+    managementToken: string;
+};
+/**
+ * AWS Horizon machine image catalog.
+ */
+export type TargetDeploymentHorizonMachineImageAws = {
+    /**
+     * AMI IDs by architecture, then AWS region.
+     */
+    amis: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    };
+};
+export type TargetDeploymentHorizonMachineImageAwsUnion = TargetDeploymentHorizonMachineImageAws | string;
+/**
+ * Azure Horizon machine image entry.
+ */
+export type TargetDeploymentAzureImages = {
+    /**
+     * Azure Compute Gallery image version ID.
+     */
+    imageVersionId: string;
+};
+/**
+ * Azure Horizon machine image catalog.
+ */
+export type HorizonMachineImageAzureConfig = {
+    /**
+     * Images by architecture.
+     */
+    images: {
+        [k: string]: TargetDeploymentAzureImages;
+    };
+};
+export type HorizonMachineImageConfigAzureUnion = HorizonMachineImageAzureConfig | string;
+/**
+ * Base image metadata for the Horizon machine image.
+ */
+export type TargetDeploymentBaseImage = {
+    /**
+     * Base OS image name.
+     */
+    name: string;
+    /**
+     * Base OS image version or channel.
+     */
+    version: string;
+};
+/**
+ * GCP Horizon machine image entry.
+ */
+export type TargetDeploymentGcpImages = {
+    /**
+     * Source image self link or image-family URL.
+     */
+    sourceImage: string;
+};
+/**
+ * GCP Horizon machine image catalog.
+ */
+export type HorizonMachineImageGcpConfig = {
+    /**
+     * Images by architecture.
+     */
+    images: {
+        [k: string]: TargetDeploymentGcpImages;
+    };
+};
+export type HorizonMachineImageConfigGcpUnion = HorizonMachineImageGcpConfig | string;
+/**
+ * Download artifact for one horizond release platform.
+ */
+export type TargetDeploymentHorizondArtifacts = {
+    /**
+     * Runtime isolation capability generation of the immutable artifact, not live readiness.
+     */
+    runtimeIsolationGeneration?: number | undefined;
+    /**
+     * SHA-256 digest for the artifact payload.
+     */
+    sha256: string;
+    /**
+     * HTTPS URL for the artifact.
+     */
+    url: string;
+};
+/**
+ * Horizon machine image catalog.
+ *
+ * @remarks
+ *
+ * Platform resolves concrete provider images from this catalog during rollout.
+ */
+export type TargetDeploymentHorizonMachineImage = {
+    aws?: TargetDeploymentHorizonMachineImageAws | string | null | undefined;
+    azure?: HorizonMachineImageAzureConfig | string | null | undefined;
+    /**
+     * Base image metadata for the Horizon machine image.
+     */
+    baseImage: TargetDeploymentBaseImage;
+    /**
+     * Logical image channel, such as prod, staging, or canary.
+     */
+    channel: string;
+    /**
+     * Image manifest creation timestamp.
+     */
+    createdAt: string;
+    gcp?: HorizonMachineImageGcpConfig | string | null | undefined;
+    /**
+     * Git commit SHA used to build the image.
+     */
+    gitSha: string;
+    /**
+     * Per-architecture horizond artifacts by release-platform key.
+     */
+    horizondArtifacts: {
+        [k: string]: TargetDeploymentHorizondArtifacts;
+    };
+    /**
+     * horizond daemon version baked into the image.
+     */
+    horizondVersion: string;
+    /**
+     * Published immutable machine image version.
+     */
+    machineImageVersion: string;
+    /**
+     * Runtime isolation capability generation of the immutable artifact, not live readiness.
+     */
+    runtimeIsolationGeneration?: number | undefined;
+};
+export type TargetDeploymentHorizonMachineImageUnion = TargetDeploymentHorizonMachineImage | string;
+export declare const TargetDeploymentComputeBackendType: {
+    readonly Horizon: "horizon";
+};
+export type TargetDeploymentComputeBackendType = ClosedEnum<typeof TargetDeploymentComputeBackendType>;
+/**
+ * Compute backend for Container and Worker resources.
+ *
+ * @remarks
+ *
+ * Determines how compute workloads are orchestrated on cloud platforms.
+ * When None, the platform default is used for cloud platforms.
+ */
+export type TargetDeploymentComputeBackendHorizon = {
+    /**
+     * Cluster configurations (one per ComputeCluster resource)
+     *
+     * @remarks
+     * Key: ComputeCluster resource ID from stack
+     * Value: Cluster ID and management token for that cluster
+     */
+    clusters: {
+        [k: string]: TargetDeploymentClusters;
+    };
+    horizonMachineImage?: TargetDeploymentHorizonMachineImage | string | null | undefined;
+    /**
+     * Horizon control-plane API base URL.
+     */
+    url: string;
+    type: TargetDeploymentComputeBackendType;
+};
+export type TargetDeploymentComputeBackendUnion = TargetDeploymentComputeBackendHorizon | string;
+/**
+ * Certificate status in the certificate lifecycle
+ */
+export declare const TargetDeploymentAliasCertificateStatus: {
+    readonly Pending: "pending";
+    readonly Issued: "issued";
+    readonly Renewing: "renewing";
+    readonly RenewalFailed: "renewal-failed";
+    readonly Failed: "failed";
+    readonly Deleting: "deleting";
+};
+/**
+ * Certificate status in the certificate lifecycle
+ */
+export type TargetDeploymentAliasCertificateStatus = ClosedEnum<typeof TargetDeploymentAliasCertificateStatus>;
+/**
+ * DNS record status in the DNS lifecycle
+ */
+export declare const TargetDeploymentAliasDnsStatus: {
+    readonly Pending: "pending";
+    readonly Active: "active";
+    readonly Updating: "updating";
+    readonly Deleting: "deleting";
+    readonly Failed: "failed";
+};
+/**
+ * DNS record status in the DNS lifecycle
+ */
+export type TargetDeploymentAliasDnsStatus = ClosedEnum<typeof TargetDeploymentAliasDnsStatus>;
+/**
+ * Certificate and DNS metadata for a managed hostname.
+ *
+ * @remarks
+ *
+ * Includes decrypted certificate data for issued certificates.
+ * Private keys are deployment-scoped secrets (like environment variables).
+ */
+export type TargetDeploymentAlias = {
+    /**
+     * Full PEM certificate chain (only present if status is "issued").
+     */
+    certificateChain?: string | null | undefined;
+    /**
+     * Certificate ID (for tracking/logging).
+     */
+    certificateId: string;
+    /**
+     * Certificate status in the certificate lifecycle
+     */
+    certificateStatus: TargetDeploymentAliasCertificateStatus;
+    /**
+     * Last DNS error message. Present when DNS previously failed, even if status
+     *
+     * @remarks
+     * was reset to pending for retry. Used to surface actionable error context
+     * in WaitingForDns failure messages.
+     */
+    dnsError?: string | null | undefined;
+    /**
+     * DNS record status in the DNS lifecycle
+     */
+    dnsStatus: TargetDeploymentAliasDnsStatus;
+    /**
+     * Fully qualified domain name.
+     */
+    fqdn: string;
+    /**
+     * ISO 8601 timestamp when certificate was issued (for renewal detection).
+     */
+    issuedAt?: string | null | undefined;
+    /**
+     * Decrypted private key (only present if status is "issued").
+     */
+    privateKey?: string | null | undefined;
+};
+/**
+ * Certificate status in the certificate lifecycle
+ */
+export declare const TargetDeploymentCertificateStatus: {
+    readonly Pending: "pending";
+    readonly Issued: "issued";
+    readonly Renewing: "renewing";
+    readonly RenewalFailed: "renewal-failed";
+    readonly Failed: "failed";
+    readonly Deleting: "deleting";
+};
+/**
+ * Certificate status in the certificate lifecycle
+ */
+export type TargetDeploymentCertificateStatus = ClosedEnum<typeof TargetDeploymentCertificateStatus>;
+/**
+ * DNS record status in the DNS lifecycle
+ */
+export declare const TargetDeploymentDnsStatus: {
+    readonly Pending: "pending";
+    readonly Active: "active";
+    readonly Updating: "updating";
+    readonly Deleting: "deleting";
+    readonly Failed: "failed";
+};
+/**
+ * DNS record status in the DNS lifecycle
+ */
+export type TargetDeploymentDnsStatus = ClosedEnum<typeof TargetDeploymentDnsStatus>;
+/**
+ * Certificate status in the certificate lifecycle
+ */
+export declare const TargetDeploymentEndpointsCertificateStatus: {
+    readonly Pending: "pending";
+    readonly Issued: "issued";
+    readonly Renewing: "renewing";
+    readonly RenewalFailed: "renewal-failed";
+    readonly Failed: "failed";
+    readonly Deleting: "deleting";
+};
+/**
+ * Certificate status in the certificate lifecycle
+ */
+export type TargetDeploymentEndpointsCertificateStatus = ClosedEnum<typeof TargetDeploymentEndpointsCertificateStatus>;
+/**
+ * DNS record status in the DNS lifecycle
+ */
+export declare const TargetDeploymentEndpointsDnsStatus: {
+    readonly Pending: "pending";
+    readonly Active: "active";
+    readonly Updating: "updating";
+    readonly Deleting: "deleting";
+    readonly Failed: "failed";
+};
+/**
+ * DNS record status in the DNS lifecycle
+ */
+export type TargetDeploymentEndpointsDnsStatus = ClosedEnum<typeof TargetDeploymentEndpointsDnsStatus>;
+/**
+ * Certificate and DNS metadata for a managed hostname.
+ *
+ * @remarks
+ *
+ * Includes decrypted certificate data for issued certificates.
+ * Private keys are deployment-scoped secrets (like environment variables).
+ */
+export type TargetDeploymentEndpoints = {
+    /**
+     * Full PEM certificate chain (only present if status is "issued").
+     */
+    certificateChain?: string | null | undefined;
+    /**
+     * Certificate ID (for tracking/logging).
+     */
+    certificateId: string;
+    /**
+     * Certificate status in the certificate lifecycle
+     */
+    certificateStatus: TargetDeploymentEndpointsCertificateStatus;
+    /**
+     * Last DNS error message. Present when DNS previously failed, even if status
+     *
+     * @remarks
+     * was reset to pending for retry. Used to surface actionable error context
+     * in WaitingForDns failure messages.
+     */
+    dnsError?: string | null | undefined;
+    /**
+     * DNS record status in the DNS lifecycle
+     */
+    dnsStatus: TargetDeploymentEndpointsDnsStatus;
+    /**
+     * Fully qualified domain name.
+     */
+    fqdn: string;
+    /**
+     * ISO 8601 timestamp when certificate was issued (for renewal detection).
+     */
+    issuedAt?: string | null | undefined;
+    /**
+     * Decrypted private key (only present if status is "issued").
+     */
+    privateKey?: string | null | undefined;
+};
+/**
+ * Certificate and DNS metadata for a public resource.
+ *
+ * @remarks
+ *
+ * The direct fields describe the primary endpoint hostname. `endpoints`
+ * contains endpoint-scoped metadata keyed by endpoint name. `aliases` contains
+ * additional managed hostnames that route directly to the primary endpoint.
+ */
+export type ConfigResources = {
+    /**
+     * Additional managed hostnames for the resource.
+     */
+    aliases?: Array<TargetDeploymentAlias> | undefined;
+    /**
+     * Full PEM certificate chain (only present if status is "issued").
+     */
+    certificateChain?: string | null | undefined;
+    /**
+     * Certificate ID (for tracking/logging).
+     */
+    certificateId: string;
+    /**
+     * Certificate status in the certificate lifecycle
+     */
+    certificateStatus: TargetDeploymentCertificateStatus;
+    /**
+     * Last DNS error message.
+     */
+    dnsError?: string | null | undefined;
+    /**
+     * DNS record status in the DNS lifecycle
+     */
+    dnsStatus: TargetDeploymentDnsStatus;
+    /**
+     * Endpoint-scoped metadata keyed by endpoint name.
+     */
+    endpoints?: {
+        [k: string]: TargetDeploymentEndpoints;
+    } | undefined;
+    /**
+     * Fully qualified domain name.
+     */
+    fqdn: string;
+    /**
+     * ISO 8601 timestamp when certificate was issued (for renewal detection).
+     */
+    issuedAt?: string | null | undefined;
+    /**
+     * Decrypted private key (only present if status is "issued").
+     */
+    privateKey?: string | null | undefined;
+};
+/**
+ * Domain metadata for auto-managed public resources (no private keys).
+ */
+export type TargetDeploymentDomainMetadata = {
+    /**
+     * Base domain for auto-generated domains (e.g., "vpc.direct").
+     */
+    baseDomain: string;
+    /**
+     * Hosted zone ID for DNS records.
+     */
+    hostedZoneId: string;
+    /**
+     * Deployment public subdomain (e.g., "k8f2j3").
+     */
+    publicSubdomain: string;
+    /**
+     * Metadata per resource ID.
+     */
+    resources: {
+        [k: string]: ConfigResources;
+    };
+};
+export type TargetDeploymentDomainMetadataUnion = TargetDeploymentDomainMetadata | string;
+/**
+ * Type of environment variable
+ */
+export declare const TargetDeploymentEnvironmentVariablesType: {
+    readonly Plain: "plain";
+    readonly Secret: "secret";
+};
+/**
+ * Type of environment variable
+ */
+export type TargetDeploymentEnvironmentVariablesType = ClosedEnum<typeof TargetDeploymentEnvironmentVariablesType>;
+/**
+ * Environment variable for deployment
+ */
+export type TargetDeploymentVariable = {
+    /**
+     * Variable name
+     */
+    name: string;
+    /**
+     * Target resource patterns (null = all resources, Some = wildcard patterns)
+     */
+    targetResources?: Array<string> | null | undefined;
+    /**
+     * Type of environment variable
+     */
+    type: TargetDeploymentEnvironmentVariablesType;
+    /**
+     * Variable value (decrypted - deployment has access to decryption keys)
+     */
+    value: string;
+};
+/**
+ * Snapshot of environment variables at a point in time
+ */
+export type TargetDeploymentEnvironmentVariables = {
+    /**
+     * ISO 8601 timestamp when snapshot was created
+     */
+    createdAt: string;
+    /**
+     * Deterministic hash of all variables (for change detection)
+     */
+    hash: string;
+    /**
+     * Environment variables in the snapshot
+     */
+    variables: Array<TargetDeploymentVariable>;
+};
+export declare const ConfigPlatformKubernetes: {
+    readonly Kubernetes: "kubernetes";
+};
+export type ConfigPlatformKubernetes = ClosedEnum<typeof ConfigPlatformKubernetes>;
+export type TargetDeploymentManagementConfigKubernetes = {
+    platform: ConfigPlatformKubernetes;
+};
+export declare const ConfigPlatformAzure: {
+    readonly Azure: "azure";
+};
+export type ConfigPlatformAzure = ClosedEnum<typeof ConfigPlatformAzure>;
+/**
+ * Azure management configuration extracted from stack settings
+ */
+export type TargetDeploymentManagementConfigAzure = {
+    /**
+     * The managing Azure Tenant ID for cross-tenant access
+     */
+    managingTenantId: string;
+    /**
+     * OIDC issuer URL trusted by the target-side managed identity.
+     */
+    oidcIssuer: string;
+    /**
+     * OIDC subject claim trusted by the target-side managed identity.
+     */
+    oidcSubject: string;
+    platform: ConfigPlatformAzure;
+};
+export declare const ConfigPlatformGcp: {
+    readonly Gcp: "gcp";
+};
+export type ConfigPlatformGcp = ClosedEnum<typeof ConfigPlatformGcp>;
+/**
+ * GCP management configuration extracted from stack settings
+ */
+export type TargetDeploymentManagementConfigGcp = {
+    /**
+     * Service account email for management roles
+     */
+    serviceAccountEmail: string;
+    platform: ConfigPlatformGcp;
+};
+export declare const ConfigPlatformAws: {
+    readonly Aws: "aws";
+};
+export type ConfigPlatformAws = ClosedEnum<typeof ConfigPlatformAws>;
+/**
+ * AWS management configuration extracted from stack settings
+ */
+export type TargetDeploymentManagementConfigAws = {
+    /**
+     * The managing AWS IAM role ARN that can assume cross-account roles
+     */
+    managingRoleArn: string;
+    platform: ConfigPlatformAws;
+};
+export type TargetDeploymentManagementConfigUnion = TargetDeploymentManagementConfigAzure | TargetDeploymentManagementConfigAws | TargetDeploymentManagementConfigGcp | TargetDeploymentManagementConfigKubernetes | string;
+/**
+ * OTLP log export configuration for a deployment.
+ *
+ * @remarks
+ *
+ * When set, injected compute runtimes export captured application logs
+ * through the given endpoint via OTLP/HTTP; which resources are injected
+ * is platform-dependent. Workers read auth headers from a runtime-only
+ * secret. Runtime-less Containers and Daemons receive standard OTEL auth
+ * variables only at the final hosting boundary: Local passes them directly
+ * to the process and Kubernetes projects them from a per-workload Secret.
+ */
+export type TargetDeploymentMonitoring = {
+    /**
+     * Auth header value in "key=value,..." format.
+     *
+     * @remarks
+     * Example: "authorization=Bearer <write-token>"
+     */
+    logsAuthHeader: string;
+    /**
+     * Full OTLP logs endpoint URL.
+     *
+     * @remarks
+     * Example: "https://<manager-host>/v1/logs"
+     */
+    logsEndpoint: string;
+    /**
+     * Auth header value for the metrics endpoint in "key=value,..." format (optional).
+     *
+     * @remarks
+     *
+     * When absent, `logs_auth_header` is reused for metrics -- suitable when the same
+     * credential covers both signals. When present (e.g. Axiom with separate datasets),
+     * this value is used exclusively for metrics.
+     *
+     * Example: "authorization=Bearer <token>,x-axiom-dataset=<metrics-dataset>"
+     */
+    metricsAuthHeader?: string | null | undefined;
+    /**
+     * Full OTLP metrics endpoint URL (optional).
+     *
+     * @remarks
+     * When set, the worker runtime exports its own VM/container orchestration metrics here.
+     * Example: "https://api.axiom.co/v1/metrics"
+     */
+    metricsEndpoint?: string | null | undefined;
+    /**
+     * Resource attributes attached to every OTLP signal emitted for this deployment.
+     *
+     * @remarks
+     *
+     * Platform managers use this for stable identity such as `alien.workspace_id`,
+     * `alien.project_id`, `alien.deployment_group_id`, and `alien.deployment_id`.
+     * Runtime-specific resource attributes such as `service.name` remain owned by
+     * the runtime/exporter.
+     */
+    resourceAttributes?: {
+        [k: string]: string;
+    } | undefined;
+};
+export type TargetDeploymentMonitoringUnion = TargetDeploymentMonitoring | string;
+/**
+ * Deployment-time resource allocation for a container. Omitted fields use release defaults.
+ */
+export type TargetDeploymentContainers = {
+    /**
+     * CPU allocation in vCPUs.
+     */
+    cpu?: number | null | undefined;
+    /**
+     * Memory allocation, using binary units such as Mi or Gi.
+     */
+    memory?: string | null | undefined;
+    /**
+     * Persistent volume capacity per replica, in whole GiB. Omitted values
+     *
+     * @remarks
+     * use the release default. Existing volumes can only grow.
+     */
+    volumeSizeGib?: number | null | undefined;
+};
+/**
+ * Failure-domain policy selected for a compute pool.
+ */
+export type TargetDeploymentFailureDomains2 = {
+    /**
+     * 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 TargetDeploymentFailureDomainsUnion2 = TargetDeploymentFailureDomains2 | string;
+export type TargetDeploymentPoolsAutoscale = {
+    failureDomains?: TargetDeploymentFailureDomains2 | string | null | undefined;
+    /**
+     * Provider machine type selected for this deployment.
+     */
+    machine?: string | null | undefined;
+    /**
+     * Maximum machine count.
+     */
+    max: number;
+    /**
+     * Minimum machine count.
+     */
+    min: number;
+    mode: "autoscale";
+};
+/**
+ * Failure-domain policy selected for a compute pool.
+ */
+export type TargetDeploymentFailureDomains1 = {
+    /**
+     * 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 TargetDeploymentFailureDomainsUnion1 = TargetDeploymentFailureDomains1 | string;
+export type TargetDeploymentPoolsFixed = {
+    failureDomains?: TargetDeploymentFailureDomains1 | string | null | undefined;
+    /**
+     * Provider machine type selected for this deployment.
+     */
+    machine?: string | null | undefined;
+    /**
+     * Number of machines to run.
+     */
+    machines: number;
+    mode: "fixed";
+};
+/**
+ * User-selected deployment settings for one compute pool.
+ */
+export type TargetDeploymentPoolsUnion = TargetDeploymentPoolsFixed | TargetDeploymentPoolsAutoscale;
+/**
+ * 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 TargetDeploymentCompute = {
+    /**
+     * Per-replica resources selected within each container's declared ranges.
+     */
+    containers?: {
+        [k: string]: TargetDeploymentContainers;
+    } | undefined;
+    /**
+     * Selected compute choices keyed by pool ID.
+     */
+    pools?: {
+        [k: string]: TargetDeploymentPoolsFixed | TargetDeploymentPoolsAutoscale;
+    } | undefined;
+};
+export type TargetDeploymentComputeUnion = TargetDeploymentCompute | string;
+/**
+ * Deployment model: how updates are delivered to the remote environment.
+ */
+export declare const TargetDeploymentDeploymentModel: {
+    readonly Push: "push";
+    readonly Pull: "pull";
+};
+/**
+ * Deployment model: how updates are delivered to the remote environment.
+ */
+export type TargetDeploymentDeploymentModel = ClosedEnum<typeof TargetDeploymentDeploymentModel>;
+export type TargetDeploymentAwsStackSettings = {
+    certificateArn: string;
+};
+export type TargetDeploymentStackSettingsAwsUnion = TargetDeploymentAwsStackSettings | string;
+export type AzureConfigStackSettings = {
+    keyVaultCertificateId: string;
+    keyVaultResourceId?: string | null | undefined;
+};
+export type ConfigStackSettingsAzureUnion = AzureConfigStackSettings | string;
+export type GcpConfigStackSettings = {
+    certificateName: string;
+};
+export type ConfigStackSettingsGcpUnion = GcpConfigStackSettings | string;
+/**
+ * Namespace-scoped Kubernetes TLS Secret reference.
+ */
+export type TargetDeploymentTlsSecretRef = {
+    /**
+     * Secret namespace. Defaults to the release namespace when omitted.
+     */
+    namespace?: string | null | undefined;
+    /**
+     * Secret name.
+     */
+    secretName: string;
+};
+export type TargetDeploymentDomainsKubernetes = {
+    /**
+     * Namespace-scoped Kubernetes TLS Secret reference.
+     */
+    tlsSecretRef: TargetDeploymentTlsSecretRef;
+};
+export type TargetDeploymentDomainsKubernetesUnion = TargetDeploymentDomainsKubernetes | string;
+/**
+ * Platform-specific certificate references for custom domains.
+ */
+export type TargetDeploymentDomainsCertificate = {
+    aws?: TargetDeploymentAwsStackSettings | string | null | undefined;
+    azure?: AzureConfigStackSettings | string | null | undefined;
+    gcp?: GcpConfigStackSettings | string | null | undefined;
+    kubernetes?: TargetDeploymentDomainsKubernetes | string | null | undefined;
+};
+/**
+ * Custom domain configuration for a single resource.
+ */
+export type TargetDeploymentCustomDomains = {
+    /**
+     * Platform-specific certificate references for custom domains.
+     */
+    certificate: TargetDeploymentDomainsCertificate;
+    /**
+     * Fully qualified domain name to use.
+     */
+    domain: string;
+};
+export declare const TargetDeploymentModeLoadBalancer: {
+    readonly LoadBalancer: "loadBalancer";
+};
+export type TargetDeploymentModeLoadBalancer = ClosedEnum<typeof TargetDeploymentModeLoadBalancer>;
+export type TargetDeploymentPublicEndpointTargetLoadBalancer = {
+    /**
+     * DNS name or URL for the external load balancer.
+     */
+    cnameTarget: string;
+    mode: TargetDeploymentModeLoadBalancer;
+};
+export declare const TargetDeploymentModeMachineAddresses: {
+    readonly MachineAddresses: "machineAddresses";
+};
+export type TargetDeploymentModeMachineAddresses = ClosedEnum<typeof TargetDeploymentModeMachineAddresses>;
+export type TargetDeploymentPublicEndpointTargetMachineAddresses = {
+    mode: TargetDeploymentModeMachineAddresses;
+};
+export type TargetDeploymentPublicEndpointTargetUnion = TargetDeploymentPublicEndpointTargetLoadBalancer | TargetDeploymentPublicEndpointTargetMachineAddresses | string;
+/**
+ * Domain configuration for the stack.
+ *
+ * @remarks
+ *
+ * When `custom_domains` is set, the specified resources use customer-provided
+ * domains and certificates. Otherwise, Alien auto-generates domains.
+ */
+export type TargetDeploymentDomains = {
+    /**
+     * Custom domain configuration per resource ID.
+     */
+    customDomains?: {
+        [k: string]: TargetDeploymentCustomDomains;
+    } | null | undefined;
+    publicEndpointTarget?: TargetDeploymentPublicEndpointTargetLoadBalancer | TargetDeploymentPublicEndpointTargetMachineAddresses | string | null | undefined;
+};
+export type TargetDeploymentDomainsUnion = TargetDeploymentDomains | string;
+/**
+ * Reachability of the deployment's public endpoints, fixed at setup.
+ */
+export declare const TargetDeploymentEndpointAccess: {
+    readonly Internet: "internet";
+    readonly Private: "private";
+};
+/**
+ * Reachability of the deployment's public endpoints, fixed at setup.
+ */
+export type TargetDeploymentEndpointAccess = ClosedEnum<typeof TargetDeploymentEndpointAccess>;
+/**
+ * How heartbeat health checks are handled.
+ */
+export declare const TargetDeploymentHeartbeats: {
+    readonly Off: "off";
+    readonly On: "on";
+};
+/**
+ * How heartbeat health checks are handled.
+ */
+export type TargetDeploymentHeartbeats = ClosedEnum<typeof TargetDeploymentHeartbeats>;
+/**
+ * Optional provider-specific identity for a cloud-backed Kubernetes cluster.
+ */
+export type TargetDeploymentCloud = {
+    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 TargetDeploymentCloudUnion = TargetDeploymentCloud | string;
+/**
+ * Ownership model for the Kubernetes cluster.
+ */
+export declare const TargetDeploymentOwnership: {
+    readonly Managed: "managed";
+    readonly Existing: "existing";
+    readonly External: "external";
+};
+/**
+ * Ownership model for the Kubernetes cluster.
+ */
+export type TargetDeploymentOwnership = ClosedEnum<typeof TargetDeploymentOwnership>;
+/**
+ * Kubernetes cluster setup settings.
+ */
+export type TargetDeploymentCluster = {
+    cloud?: TargetDeploymentCloud | string | null | undefined;
+    /**
+     * Namespace where the Alien chart and application resources run.
+     */
+    namespace?: string | null | undefined;
+    /**
+     * Ownership model for the Kubernetes cluster.
+     */
+    ownership: TargetDeploymentOwnership;
+};
+export type TargetDeploymentClusterUnion = TargetDeploymentCluster | string;
+export type TargetDeploymentCertificateNone2 = {
+    mode: "none";
+};
+export type TargetDeploymentCertificateManagedTLSSecret2 = {
+    mode: "managedTlsSecret";
+    /**
+     * Secret name template. Runtime may substitute resource/deployment tokens.
+     */
+    secretNameTemplate: string;
+};
+export type TargetDeploymentCertificateAwsAcmArn2 = {
+    /**
+     * Existing ACM certificate ARN.
+     */
+    certificateArn: string;
+    mode: "awsAcmArn";
+};
+export type TargetDeploymentCertificateManagedAcmImport2 = {
+    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 TargetDeploymentCertificateTLSSecretRef2 = {
+    /**
+     * 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 TargetDeploymentCertificateUnion2 = TargetDeploymentCertificateTLSSecretRef2 | TargetDeploymentCertificateManagedAcmImport2 | TargetDeploymentCertificateAwsAcmArn2 | TargetDeploymentCertificateManagedTLSSecret2 | TargetDeploymentCertificateNone2;
+export declare const TargetDeploymentModeCustom: {
+    readonly Custom: "custom";
+};
+export type TargetDeploymentModeCustom = ClosedEnum<typeof TargetDeploymentModeCustom>;
+export declare const TargetDeploymentProviderAzureApplicationGatewayForContainersEnum4: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+export type TargetDeploymentProviderAzureApplicationGatewayForContainersEnum4 = ClosedEnum<typeof TargetDeploymentProviderAzureApplicationGatewayForContainersEnum4>;
+export type TargetDeploymentProviderAzureApplicationGatewayForContainers4 = {
+    /**
+     * 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: TargetDeploymentProviderAzureApplicationGatewayForContainersEnum4;
+};
+export declare const TargetDeploymentProviderGkeGatewayEnum4: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type TargetDeploymentProviderGkeGatewayEnum4 = ClosedEnum<typeof TargetDeploymentProviderGkeGatewayEnum4>;
+export type TargetDeploymentProviderGkeGateway4 = {
+    provider: TargetDeploymentProviderGkeGatewayEnum4;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const TargetDeploymentProviderAwsAlbEnum4: {
+    readonly AwsAlb: "awsAlb";
+};
+export type TargetDeploymentProviderAwsAlbEnum4 = ClosedEnum<typeof TargetDeploymentProviderAwsAlbEnum4>;
+export type TargetDeploymentProviderAwsAlb4 = {
+    /**
+     * Optional ALB IP address type, such as `dualstack`.
+     */
+    ipAddressType?: string | null | undefined;
+    provider: TargetDeploymentProviderAwsAlbEnum4;
+    /**
+     * 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 TargetDeploymentProviderUnion4 = TargetDeploymentProviderAwsAlb4 | TargetDeploymentProviderAzureApplicationGatewayForContainers4 | TargetDeploymentProviderGkeGateway4 | string;
+/**
+ * Shared Gateway API route profile values.
+ */
+export type TargetDeploymentRouteGateway2 = {
+    /**
+     * 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?: TargetDeploymentProviderAwsAlb4 | TargetDeploymentProviderAzureApplicationGatewayForContainers4 | TargetDeploymentProviderGkeGateway4 | string | null | undefined;
+    routeApi: "gateway";
+};
+export declare const TargetDeploymentProviderAzureApplicationGatewayForContainersEnum3: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+export type TargetDeploymentProviderAzureApplicationGatewayForContainersEnum3 = ClosedEnum<typeof TargetDeploymentProviderAzureApplicationGatewayForContainersEnum3>;
+export type TargetDeploymentProviderAzureApplicationGatewayForContainers3 = {
+    /**
+     * 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: TargetDeploymentProviderAzureApplicationGatewayForContainersEnum3;
+};
+export declare const TargetDeploymentProviderGkeGatewayEnum3: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type TargetDeploymentProviderGkeGatewayEnum3 = ClosedEnum<typeof TargetDeploymentProviderGkeGatewayEnum3>;
+export type TargetDeploymentProviderGkeGateway3 = {
+    provider: TargetDeploymentProviderGkeGatewayEnum3;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const TargetDeploymentProviderAwsAlbEnum3: {
+    readonly AwsAlb: "awsAlb";
+};
+export type TargetDeploymentProviderAwsAlbEnum3 = ClosedEnum<typeof TargetDeploymentProviderAwsAlbEnum3>;
+export type TargetDeploymentProviderAwsAlb3 = {
+    /**
+     * Optional ALB IP address type, such as `dualstack`.
+     */
+    ipAddressType?: string | null | undefined;
+    provider: TargetDeploymentProviderAwsAlbEnum3;
+    /**
+     * 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 TargetDeploymentProviderUnion3 = TargetDeploymentProviderAwsAlb3 | TargetDeploymentProviderAzureApplicationGatewayForContainers3 | TargetDeploymentProviderGkeGateway3 | string;
+/**
+ * Shared Ingress route profile values.
+ */
+export type TargetDeploymentRouteIngress2 = {
+    /**
+     * 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?: TargetDeploymentProviderAwsAlb3 | TargetDeploymentProviderAzureApplicationGatewayForContainers3 | TargetDeploymentProviderGkeGateway3 | string | null | undefined;
+    routeApi: "ingress";
+};
+/**
+ * Kubernetes route API selected for public endpoints.
+ */
+export type TargetDeploymentRouteUnion2 = TargetDeploymentRouteIngress2 | TargetDeploymentRouteGateway2;
+export type TargetDeploymentExposureCustom = {
+    /**
+     * Certificate publication or reference mode for Kubernetes public endpoints.
+     */
+    certificate: TargetDeploymentCertificateTLSSecretRef2 | TargetDeploymentCertificateManagedAcmImport2 | TargetDeploymentCertificateAwsAcmArn2 | TargetDeploymentCertificateManagedTLSSecret2 | TargetDeploymentCertificateNone2;
+    /**
+     * Hostname routed by the Kubernetes public endpoint.
+     */
+    domain: string;
+    mode: TargetDeploymentModeCustom;
+    /**
+     * Kubernetes route API selected for public endpoints.
+     */
+    route: TargetDeploymentRouteIngress2 | TargetDeploymentRouteGateway2;
+};
+export type TargetDeploymentCertificateNone1 = {
+    mode: "none";
+};
+export type TargetDeploymentCertificateManagedTLSSecret1 = {
+    mode: "managedTlsSecret";
+    /**
+     * Secret name template. Runtime may substitute resource/deployment tokens.
+     */
+    secretNameTemplate: string;
+};
+export type TargetDeploymentCertificateAwsAcmArn1 = {
+    /**
+     * Existing ACM certificate ARN.
+     */
+    certificateArn: string;
+    mode: "awsAcmArn";
+};
+export type TargetDeploymentCertificateManagedAcmImport1 = {
+    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 TargetDeploymentCertificateTLSSecretRef1 = {
+    /**
+     * 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 TargetDeploymentCertificateUnion1 = TargetDeploymentCertificateTLSSecretRef1 | TargetDeploymentCertificateManagedAcmImport1 | TargetDeploymentCertificateAwsAcmArn1 | TargetDeploymentCertificateManagedTLSSecret1 | TargetDeploymentCertificateNone1;
+export declare const TargetDeploymentModeGenerated: {
+    readonly Generated: "generated";
+};
+export type TargetDeploymentModeGenerated = ClosedEnum<typeof TargetDeploymentModeGenerated>;
+export declare const TargetDeploymentProviderAzureApplicationGatewayForContainersEnum2: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+export type TargetDeploymentProviderAzureApplicationGatewayForContainersEnum2 = ClosedEnum<typeof TargetDeploymentProviderAzureApplicationGatewayForContainersEnum2>;
+export type TargetDeploymentProviderAzureApplicationGatewayForContainers2 = {
+    /**
+     * 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: TargetDeploymentProviderAzureApplicationGatewayForContainersEnum2;
+};
+export declare const TargetDeploymentProviderGkeGatewayEnum2: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type TargetDeploymentProviderGkeGatewayEnum2 = ClosedEnum<typeof TargetDeploymentProviderGkeGatewayEnum2>;
+export type TargetDeploymentProviderGkeGateway2 = {
+    provider: TargetDeploymentProviderGkeGatewayEnum2;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const TargetDeploymentProviderAwsAlbEnum2: {
+    readonly AwsAlb: "awsAlb";
+};
+export type TargetDeploymentProviderAwsAlbEnum2 = ClosedEnum<typeof TargetDeploymentProviderAwsAlbEnum2>;
+export type TargetDeploymentProviderAwsAlb2 = {
+    /**
+     * Optional ALB IP address type, such as `dualstack`.
+     */
+    ipAddressType?: string | null | undefined;
+    provider: TargetDeploymentProviderAwsAlbEnum2;
+    /**
+     * 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 TargetDeploymentProviderUnion2 = TargetDeploymentProviderAwsAlb2 | TargetDeploymentProviderAzureApplicationGatewayForContainers2 | TargetDeploymentProviderGkeGateway2 | string;
+/**
+ * Shared Gateway API route profile values.
+ */
+export type TargetDeploymentRouteGateway1 = {
+    /**
+     * 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?: TargetDeploymentProviderAwsAlb2 | TargetDeploymentProviderAzureApplicationGatewayForContainers2 | TargetDeploymentProviderGkeGateway2 | string | null | undefined;
+    routeApi: "gateway";
+};
+export declare const TargetDeploymentProviderAzureApplicationGatewayForContainersEnum1: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+export type TargetDeploymentProviderAzureApplicationGatewayForContainersEnum1 = ClosedEnum<typeof TargetDeploymentProviderAzureApplicationGatewayForContainersEnum1>;
+export type TargetDeploymentProviderAzureApplicationGatewayForContainers1 = {
+    /**
+     * 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: TargetDeploymentProviderAzureApplicationGatewayForContainersEnum1;
+};
+export declare const TargetDeploymentProviderGkeGatewayEnum1: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type TargetDeploymentProviderGkeGatewayEnum1 = ClosedEnum<typeof TargetDeploymentProviderGkeGatewayEnum1>;
+export type TargetDeploymentProviderGkeGateway1 = {
+    provider: TargetDeploymentProviderGkeGatewayEnum1;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const TargetDeploymentProviderAwsAlbEnum1: {
+    readonly AwsAlb: "awsAlb";
+};
+export type TargetDeploymentProviderAwsAlbEnum1 = ClosedEnum<typeof TargetDeploymentProviderAwsAlbEnum1>;
+export type TargetDeploymentProviderAwsAlb1 = {
+    /**
+     * Optional ALB IP address type, such as `dualstack`.
+     */
+    ipAddressType?: string | null | undefined;
+    provider: TargetDeploymentProviderAwsAlbEnum1;
+    /**
+     * 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 TargetDeploymentProviderUnion1 = TargetDeploymentProviderAwsAlb1 | TargetDeploymentProviderAzureApplicationGatewayForContainers1 | TargetDeploymentProviderGkeGateway1 | string;
+/**
+ * Shared Ingress route profile values.
+ */
+export type TargetDeploymentRouteIngress1 = {
+    /**
+     * 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?: TargetDeploymentProviderAwsAlb1 | TargetDeploymentProviderAzureApplicationGatewayForContainers1 | TargetDeploymentProviderGkeGateway1 | string | null | undefined;
+    routeApi: "ingress";
+};
+/**
+ * Kubernetes route API selected for public endpoints.
+ */
+export type TargetDeploymentRouteUnion1 = TargetDeploymentRouteIngress1 | TargetDeploymentRouteGateway1;
+export type TargetDeploymentExposureGenerated = {
+    /**
+     * Certificate publication or reference mode for Kubernetes public endpoints.
+     */
+    certificate: TargetDeploymentCertificateTLSSecretRef1 | TargetDeploymentCertificateManagedAcmImport1 | TargetDeploymentCertificateAwsAcmArn1 | TargetDeploymentCertificateManagedTLSSecret1 | TargetDeploymentCertificateNone1;
+    mode: TargetDeploymentModeGenerated;
+    /**
+     * Kubernetes route API selected for public endpoints.
+     */
+    route: TargetDeploymentRouteIngress1 | TargetDeploymentRouteGateway1;
+};
+export declare const TargetDeploymentModeDisabled: {
+    readonly Disabled: "disabled";
+};
+export type TargetDeploymentModeDisabled = ClosedEnum<typeof TargetDeploymentModeDisabled>;
+export type TargetDeploymentExposureDisabled = {
+    mode: TargetDeploymentModeDisabled;
+};
+export type TargetDeploymentExposureUnion = TargetDeploymentExposureCustom | TargetDeploymentExposureGenerated | TargetDeploymentExposureDisabled | string;
+/**
+ * Kubernetes runtime substrate configuration.
+ *
+ * @remarks
+ *
+ * This controls how setup chooses the cluster backing `Platform::Kubernetes`
+ * deployments. When omitted, cloud-backed Kubernetes deployments default to a
+ * managed cluster and generic/on-prem Kubernetes defaults to an external
+ * cluster.
+ */
+export type TargetDeploymentKubernetes = {
+    cluster?: TargetDeploymentCluster | string | null | undefined;
+    exposure?: TargetDeploymentExposureCustom | TargetDeploymentExposureGenerated | TargetDeploymentExposureDisabled | string | null | undefined;
+};
+export type TargetDeploymentKubernetesUnion = TargetDeploymentKubernetes | string;
+export declare const TargetDeploymentTypeByoVnetAzure: {
+    readonly ByoVnetAzure: "byo-vnet-azure";
+};
+export type TargetDeploymentTypeByoVnetAzure = ClosedEnum<typeof TargetDeploymentTypeByoVnetAzure>;
+export type TargetDeploymentNetworkByoVnetAzure = {
+    /**
+     * 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: TargetDeploymentTypeByoVnetAzure;
+    /**
+     * The full resource ID of the existing VNet
+     */
+    vnetResourceId: string;
+};
+export declare const TargetDeploymentTypeByoVpcGcp: {
+    readonly ByoVpcGcp: "byo-vpc-gcp";
+};
+export type TargetDeploymentTypeByoVpcGcp = ClosedEnum<typeof TargetDeploymentTypeByoVpcGcp>;
+export type TargetDeploymentNetworkByoVpcGcp = {
+    /**
+     * 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: TargetDeploymentTypeByoVpcGcp;
+};
+export declare const TargetDeploymentTypeByoVpcAws: {
+    readonly ByoVpcAws: "byo-vpc-aws";
+};
+export type TargetDeploymentTypeByoVpcAws = ClosedEnum<typeof TargetDeploymentTypeByoVpcAws>;
+export type TargetDeploymentNetworkByoVpcAws = {
+    /**
+     * 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: TargetDeploymentTypeByoVpcAws;
+    /**
+     * The ID of the existing VPC
+     */
+    vpcId: string;
+};
+export declare const TargetDeploymentTypeCreate: {
+    readonly Create: "create";
+};
+export type TargetDeploymentTypeCreate = ClosedEnum<typeof TargetDeploymentTypeCreate>;
+export type TargetDeploymentNetworkCreate = {
+    /**
+     * 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: TargetDeploymentTypeCreate;
+};
+export declare const TargetDeploymentTypeUseDefault: {
+    readonly UseDefault: "use-default";
+};
+export type TargetDeploymentTypeUseDefault = ClosedEnum<typeof TargetDeploymentTypeUseDefault>;
+export type TargetDeploymentNetworkUseDefault = {
+    type: TargetDeploymentTypeUseDefault;
+};
+export type TargetDeploymentNetworkUnion = TargetDeploymentNetworkByoVpcAws | TargetDeploymentNetworkByoVpcGcp | TargetDeploymentNetworkByoVnetAzure | TargetDeploymentNetworkUseDefault | TargetDeploymentNetworkCreate | string;
+/**
+ * Whether setup remains a separate administrator operation.
+ */
+export declare const TargetDeploymentSetupManagement: {
+    readonly Manual: "manual";
+    readonly Automatic: "automatic";
+};
+/**
+ * Whether setup remains a separate administrator operation.
+ */
+export type TargetDeploymentSetupManagement = ClosedEnum<typeof TargetDeploymentSetupManagement>;
+/**
+ * How telemetry (logs, metrics, traces) is handled.
+ */
+export declare const TargetDeploymentTelemetry: {
+    readonly Off: "off";
+    readonly Auto: "auto";
+    readonly ApprovalRequired: "approval-required";
+};
+/**
+ * How telemetry (logs, metrics, traces) is handled.
+ */
+export type TargetDeploymentTelemetry = ClosedEnum<typeof TargetDeploymentTelemetry>;
+/**
+ * How updates are delivered to the deployment.
+ */
+export declare const TargetDeploymentUpdates: {
+    readonly Auto: "auto";
+    readonly ApprovalRequired: "approval-required";
+};
+/**
+ * How updates are delivered to the deployment.
+ */
+export type TargetDeploymentUpdates = ClosedEnum<typeof TargetDeploymentUpdates>;
+/**
+ * User-customizable deployment settings specified at deploy time.
+ *
+ * @remarks
+ *
+ * These settings are provided by the customer via CloudFormation parameters,
+ * Terraform attributes, CLI flags, or Helm values. They customize how the
+ * deployment runs and what capabilities are enabled.
+ *
+ * **Key distinction**: StackSettings is user-customizable, while ManagementConfig
+ * is platform-derived (from the Manager's ServiceAccount).
+ */
+export type TargetDeploymentStackSettings = {
+    compute?: TargetDeploymentCompute | string | null | undefined;
+    /**
+     * Deployment model: how updates are delivered to the remote environment.
+     */
+    deploymentModel?: TargetDeploymentDeploymentModel | undefined;
+    domains?: TargetDeploymentDomains | string | null | undefined;
+    /**
+     * Reachability of the deployment's public endpoints, fixed at setup.
+     */
+    endpointAccess?: TargetDeploymentEndpointAccess | undefined;
+    externalBindings?: {
+        [k: string]: ExternalBindingUnion;
+    } | null | undefined;
+    /**
+     * How heartbeat health checks are handled.
+     */
+    heartbeats?: TargetDeploymentHeartbeats | undefined;
+    kubernetes?: TargetDeploymentKubernetes | string | null | undefined;
+    network?: TargetDeploymentNetworkByoVpcAws | TargetDeploymentNetworkByoVpcGcp | TargetDeploymentNetworkByoVnetAzure | TargetDeploymentNetworkUseDefault | TargetDeploymentNetworkCreate | string | null | undefined;
+    /**
+     * Exact externally managed endpoint URLs, keyed by resource ID and endpoint name.
+     *
+     * @remarks
+     *
+     * This is intended for adopted Machines deployments whose DNS and certificates remain
+     * customer-owned. The platform passes these URLs to the runtime without creating or
+     * replacing DNS records or certificates.
+     */
+    publicEndpoints?: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    } | null | undefined;
+    /**
+     * Provider quota identities whose preflight failures become visible warnings
+     *
+     * @remarks
+     * for this deployment. Checks still run; deploy-time provider limits still apply.
+     * Unknown identities are rejected. An empty list restores normal blocking.
+     */
+    quotaWarningOverrides?: Array<string> | undefined;
+    /**
+     * Whether setup remains a separate administrator operation.
+     */
+    setupManagement?: TargetDeploymentSetupManagement | undefined;
+    /**
+     * How telemetry (logs, metrics, traces) is handled.
+     */
+    telemetry?: TargetDeploymentTelemetry | undefined;
+    /**
+     * How updates are delivered to the deployment.
+     */
+    updates?: TargetDeploymentUpdates | undefined;
+};
+/**
+ * Replace one replica's persistent volume with a new volume made from a snapshot.
+ *
+ * @remarks
+ *
+ * The controller stops the replica, snapshots the volume it is about to
+ * replace (so the restore can be undone), creates the new volume in the same
+ * zone, starts the replica on it, and deletes the replaced volume.
+ */
+export type TargetDeploymentVolumeRestore = {
+    /**
+     * Replica ordinal whose volume is replaced
+     */
+    ordinal: number;
+    /**
+     * Unique ID of this request. A controller performs each request once.
+     */
+    requestId: string;
+    /**
+     * ID of the container resource that owns the volume
+     */
+    resourceId: string;
+    /**
+     * Cloud ID of the snapshot to restore: an EBS snapshot ID, a Compute
+     *
+     * @remarks
+     * Engine snapshot name, or an Azure snapshot resource ID
+     */
+    snapshotId: string;
+};
+/** @internal */
+export declare const TargetDeploymentBasePlatformEnum$inboundSchema: z.ZodEnum<typeof TargetDeploymentBasePlatformEnum>;
+/** @internal */
+export declare const TargetDeploymentBasePlatformUnion$inboundSchema: z.ZodType<TargetDeploymentBasePlatformUnion, unknown>;
+export declare function targetDeploymentBasePlatformUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentBasePlatformUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentClusters$inboundSchema: z.ZodType<TargetDeploymentClusters, unknown>;
+export declare function targetDeploymentClustersFromJSON(jsonString: string): SafeParseResult<TargetDeploymentClusters, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentHorizonMachineImageAws$inboundSchema: z.ZodType<TargetDeploymentHorizonMachineImageAws, unknown>;
+export declare function targetDeploymentHorizonMachineImageAwsFromJSON(jsonString: string): SafeParseResult<TargetDeploymentHorizonMachineImageAws, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentHorizonMachineImageAwsUnion$inboundSchema: z.ZodType<TargetDeploymentHorizonMachineImageAwsUnion, unknown>;
+export declare function targetDeploymentHorizonMachineImageAwsUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentHorizonMachineImageAwsUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentAzureImages$inboundSchema: z.ZodType<TargetDeploymentAzureImages, unknown>;
+export declare function targetDeploymentAzureImagesFromJSON(jsonString: string): SafeParseResult<TargetDeploymentAzureImages, SDKValidationError>;
+/** @internal */
+export declare const HorizonMachineImageAzureConfig$inboundSchema: z.ZodType<HorizonMachineImageAzureConfig, unknown>;
+export declare function horizonMachineImageAzureConfigFromJSON(jsonString: string): SafeParseResult<HorizonMachineImageAzureConfig, SDKValidationError>;
+/** @internal */
+export declare const HorizonMachineImageConfigAzureUnion$inboundSchema: z.ZodType<HorizonMachineImageConfigAzureUnion, unknown>;
+export declare function horizonMachineImageConfigAzureUnionFromJSON(jsonString: string): SafeParseResult<HorizonMachineImageConfigAzureUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentBaseImage$inboundSchema: z.ZodType<TargetDeploymentBaseImage, unknown>;
+export declare function targetDeploymentBaseImageFromJSON(jsonString: string): SafeParseResult<TargetDeploymentBaseImage, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentGcpImages$inboundSchema: z.ZodType<TargetDeploymentGcpImages, unknown>;
+export declare function targetDeploymentGcpImagesFromJSON(jsonString: string): SafeParseResult<TargetDeploymentGcpImages, SDKValidationError>;
+/** @internal */
+export declare const HorizonMachineImageGcpConfig$inboundSchema: z.ZodType<HorizonMachineImageGcpConfig, unknown>;
+export declare function horizonMachineImageGcpConfigFromJSON(jsonString: string): SafeParseResult<HorizonMachineImageGcpConfig, SDKValidationError>;
+/** @internal */
+export declare const HorizonMachineImageConfigGcpUnion$inboundSchema: z.ZodType<HorizonMachineImageConfigGcpUnion, unknown>;
+export declare function horizonMachineImageConfigGcpUnionFromJSON(jsonString: string): SafeParseResult<HorizonMachineImageConfigGcpUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentHorizondArtifacts$inboundSchema: z.ZodType<TargetDeploymentHorizondArtifacts, unknown>;
+export declare function targetDeploymentHorizondArtifactsFromJSON(jsonString: string): SafeParseResult<TargetDeploymentHorizondArtifacts, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentHorizonMachineImage$inboundSchema: z.ZodType<TargetDeploymentHorizonMachineImage, unknown>;
+export declare function targetDeploymentHorizonMachineImageFromJSON(jsonString: string): SafeParseResult<TargetDeploymentHorizonMachineImage, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentHorizonMachineImageUnion$inboundSchema: z.ZodType<TargetDeploymentHorizonMachineImageUnion, unknown>;
+export declare function targetDeploymentHorizonMachineImageUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentHorizonMachineImageUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentComputeBackendType$inboundSchema: z.ZodEnum<typeof TargetDeploymentComputeBackendType>;
+/** @internal */
+export declare const TargetDeploymentComputeBackendHorizon$inboundSchema: z.ZodType<TargetDeploymentComputeBackendHorizon, unknown>;
+export declare function targetDeploymentComputeBackendHorizonFromJSON(jsonString: string): SafeParseResult<TargetDeploymentComputeBackendHorizon, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentComputeBackendUnion$inboundSchema: z.ZodType<TargetDeploymentComputeBackendUnion, unknown>;
+export declare function targetDeploymentComputeBackendUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentComputeBackendUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentAliasCertificateStatus$inboundSchema: z.ZodEnum<typeof TargetDeploymentAliasCertificateStatus>;
+/** @internal */
+export declare const TargetDeploymentAliasDnsStatus$inboundSchema: z.ZodEnum<typeof TargetDeploymentAliasDnsStatus>;
+/** @internal */
+export declare const TargetDeploymentAlias$inboundSchema: z.ZodType<TargetDeploymentAlias, unknown>;
+export declare function targetDeploymentAliasFromJSON(jsonString: string): SafeParseResult<TargetDeploymentAlias, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCertificateStatus$inboundSchema: z.ZodEnum<typeof TargetDeploymentCertificateStatus>;
+/** @internal */
+export declare const TargetDeploymentDnsStatus$inboundSchema: z.ZodEnum<typeof TargetDeploymentDnsStatus>;
+/** @internal */
+export declare const TargetDeploymentEndpointsCertificateStatus$inboundSchema: z.ZodEnum<typeof TargetDeploymentEndpointsCertificateStatus>;
+/** @internal */
+export declare const TargetDeploymentEndpointsDnsStatus$inboundSchema: z.ZodEnum<typeof TargetDeploymentEndpointsDnsStatus>;
+/** @internal */
+export declare const TargetDeploymentEndpoints$inboundSchema: z.ZodType<TargetDeploymentEndpoints, unknown>;
+export declare function targetDeploymentEndpointsFromJSON(jsonString: string): SafeParseResult<TargetDeploymentEndpoints, SDKValidationError>;
+/** @internal */
+export declare const ConfigResources$inboundSchema: z.ZodType<ConfigResources, unknown>;
+export declare function configResourcesFromJSON(jsonString: string): SafeParseResult<ConfigResources, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentDomainMetadata$inboundSchema: z.ZodType<TargetDeploymentDomainMetadata, unknown>;
+export declare function targetDeploymentDomainMetadataFromJSON(jsonString: string): SafeParseResult<TargetDeploymentDomainMetadata, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentDomainMetadataUnion$inboundSchema: z.ZodType<TargetDeploymentDomainMetadataUnion, unknown>;
+export declare function targetDeploymentDomainMetadataUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentDomainMetadataUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentEnvironmentVariablesType$inboundSchema: z.ZodEnum<typeof TargetDeploymentEnvironmentVariablesType>;
+/** @internal */
+export declare const TargetDeploymentVariable$inboundSchema: z.ZodType<TargetDeploymentVariable, unknown>;
+export declare function targetDeploymentVariableFromJSON(jsonString: string): SafeParseResult<TargetDeploymentVariable, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentEnvironmentVariables$inboundSchema: z.ZodType<TargetDeploymentEnvironmentVariables, unknown>;
+export declare function targetDeploymentEnvironmentVariablesFromJSON(jsonString: string): SafeParseResult<TargetDeploymentEnvironmentVariables, SDKValidationError>;
+/** @internal */
+export declare const ConfigPlatformKubernetes$inboundSchema: z.ZodEnum<typeof ConfigPlatformKubernetes>;
+/** @internal */
+export declare const TargetDeploymentManagementConfigKubernetes$inboundSchema: z.ZodType<TargetDeploymentManagementConfigKubernetes, unknown>;
+export declare function targetDeploymentManagementConfigKubernetesFromJSON(jsonString: string): SafeParseResult<TargetDeploymentManagementConfigKubernetes, SDKValidationError>;
+/** @internal */
+export declare const ConfigPlatformAzure$inboundSchema: z.ZodEnum<typeof ConfigPlatformAzure>;
+/** @internal */
+export declare const TargetDeploymentManagementConfigAzure$inboundSchema: z.ZodType<TargetDeploymentManagementConfigAzure, unknown>;
+export declare function targetDeploymentManagementConfigAzureFromJSON(jsonString: string): SafeParseResult<TargetDeploymentManagementConfigAzure, SDKValidationError>;
+/** @internal */
+export declare const ConfigPlatformGcp$inboundSchema: z.ZodEnum<typeof ConfigPlatformGcp>;
+/** @internal */
+export declare const TargetDeploymentManagementConfigGcp$inboundSchema: z.ZodType<TargetDeploymentManagementConfigGcp, unknown>;
+export declare function targetDeploymentManagementConfigGcpFromJSON(jsonString: string): SafeParseResult<TargetDeploymentManagementConfigGcp, SDKValidationError>;
+/** @internal */
+export declare const ConfigPlatformAws$inboundSchema: z.ZodEnum<typeof ConfigPlatformAws>;
+/** @internal */
+export declare const TargetDeploymentManagementConfigAws$inboundSchema: z.ZodType<TargetDeploymentManagementConfigAws, unknown>;
+export declare function targetDeploymentManagementConfigAwsFromJSON(jsonString: string): SafeParseResult<TargetDeploymentManagementConfigAws, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentManagementConfigUnion$inboundSchema: z.ZodType<TargetDeploymentManagementConfigUnion, unknown>;
+export declare function targetDeploymentManagementConfigUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentManagementConfigUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentMonitoring$inboundSchema: z.ZodType<TargetDeploymentMonitoring, unknown>;
+export declare function targetDeploymentMonitoringFromJSON(jsonString: string): SafeParseResult<TargetDeploymentMonitoring, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentMonitoringUnion$inboundSchema: z.ZodType<TargetDeploymentMonitoringUnion, unknown>;
+export declare function targetDeploymentMonitoringUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentMonitoringUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentContainers$inboundSchema: z.ZodType<TargetDeploymentContainers, unknown>;
+export declare function targetDeploymentContainersFromJSON(jsonString: string): SafeParseResult<TargetDeploymentContainers, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentFailureDomains2$inboundSchema: z.ZodType<TargetDeploymentFailureDomains2, unknown>;
+export declare function targetDeploymentFailureDomains2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentFailureDomains2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentFailureDomainsUnion2$inboundSchema: z.ZodType<TargetDeploymentFailureDomainsUnion2, unknown>;
+export declare function targetDeploymentFailureDomainsUnion2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentFailureDomainsUnion2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentPoolsAutoscale$inboundSchema: z.ZodType<TargetDeploymentPoolsAutoscale, unknown>;
+export declare function targetDeploymentPoolsAutoscaleFromJSON(jsonString: string): SafeParseResult<TargetDeploymentPoolsAutoscale, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentFailureDomains1$inboundSchema: z.ZodType<TargetDeploymentFailureDomains1, unknown>;
+export declare function targetDeploymentFailureDomains1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentFailureDomains1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentFailureDomainsUnion1$inboundSchema: z.ZodType<TargetDeploymentFailureDomainsUnion1, unknown>;
+export declare function targetDeploymentFailureDomainsUnion1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentFailureDomainsUnion1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentPoolsFixed$inboundSchema: z.ZodType<TargetDeploymentPoolsFixed, unknown>;
+export declare function targetDeploymentPoolsFixedFromJSON(jsonString: string): SafeParseResult<TargetDeploymentPoolsFixed, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentPoolsUnion$inboundSchema: z.ZodType<TargetDeploymentPoolsUnion, unknown>;
+export declare function targetDeploymentPoolsUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentPoolsUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCompute$inboundSchema: z.ZodType<TargetDeploymentCompute, unknown>;
+export declare function targetDeploymentComputeFromJSON(jsonString: string): SafeParseResult<TargetDeploymentCompute, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentComputeUnion$inboundSchema: z.ZodType<TargetDeploymentComputeUnion, unknown>;
+export declare function targetDeploymentComputeUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentComputeUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentDeploymentModel$inboundSchema: z.ZodEnum<typeof TargetDeploymentDeploymentModel>;
+/** @internal */
+export declare const TargetDeploymentAwsStackSettings$inboundSchema: z.ZodType<TargetDeploymentAwsStackSettings, unknown>;
+export declare function targetDeploymentAwsStackSettingsFromJSON(jsonString: string): SafeParseResult<TargetDeploymentAwsStackSettings, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentStackSettingsAwsUnion$inboundSchema: z.ZodType<TargetDeploymentStackSettingsAwsUnion, unknown>;
+export declare function targetDeploymentStackSettingsAwsUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentStackSettingsAwsUnion, SDKValidationError>;
+/** @internal */
+export declare const AzureConfigStackSettings$inboundSchema: z.ZodType<AzureConfigStackSettings, unknown>;
+export declare function azureConfigStackSettingsFromJSON(jsonString: string): SafeParseResult<AzureConfigStackSettings, SDKValidationError>;
+/** @internal */
+export declare const ConfigStackSettingsAzureUnion$inboundSchema: z.ZodType<ConfigStackSettingsAzureUnion, unknown>;
+export declare function configStackSettingsAzureUnionFromJSON(jsonString: string): SafeParseResult<ConfigStackSettingsAzureUnion, SDKValidationError>;
+/** @internal */
+export declare const GcpConfigStackSettings$inboundSchema: z.ZodType<GcpConfigStackSettings, unknown>;
+export declare function gcpConfigStackSettingsFromJSON(jsonString: string): SafeParseResult<GcpConfigStackSettings, SDKValidationError>;
+/** @internal */
+export declare const ConfigStackSettingsGcpUnion$inboundSchema: z.ZodType<ConfigStackSettingsGcpUnion, unknown>;
+export declare function configStackSettingsGcpUnionFromJSON(jsonString: string): SafeParseResult<ConfigStackSettingsGcpUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentTlsSecretRef$inboundSchema: z.ZodType<TargetDeploymentTlsSecretRef, unknown>;
+export declare function targetDeploymentTlsSecretRefFromJSON(jsonString: string): SafeParseResult<TargetDeploymentTlsSecretRef, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentDomainsKubernetes$inboundSchema: z.ZodType<TargetDeploymentDomainsKubernetes, unknown>;
+export declare function targetDeploymentDomainsKubernetesFromJSON(jsonString: string): SafeParseResult<TargetDeploymentDomainsKubernetes, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentDomainsKubernetesUnion$inboundSchema: z.ZodType<TargetDeploymentDomainsKubernetesUnion, unknown>;
+export declare function targetDeploymentDomainsKubernetesUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentDomainsKubernetesUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentDomainsCertificate$inboundSchema: z.ZodType<TargetDeploymentDomainsCertificate, unknown>;
+export declare function targetDeploymentDomainsCertificateFromJSON(jsonString: string): SafeParseResult<TargetDeploymentDomainsCertificate, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCustomDomains$inboundSchema: z.ZodType<TargetDeploymentCustomDomains, unknown>;
+export declare function targetDeploymentCustomDomainsFromJSON(jsonString: string): SafeParseResult<TargetDeploymentCustomDomains, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentModeLoadBalancer$inboundSchema: z.ZodEnum<typeof TargetDeploymentModeLoadBalancer>;
+/** @internal */
+export declare const TargetDeploymentPublicEndpointTargetLoadBalancer$inboundSchema: z.ZodType<TargetDeploymentPublicEndpointTargetLoadBalancer, unknown>;
+export declare function targetDeploymentPublicEndpointTargetLoadBalancerFromJSON(jsonString: string): SafeParseResult<TargetDeploymentPublicEndpointTargetLoadBalancer, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentModeMachineAddresses$inboundSchema: z.ZodEnum<typeof TargetDeploymentModeMachineAddresses>;
+/** @internal */
+export declare const TargetDeploymentPublicEndpointTargetMachineAddresses$inboundSchema: z.ZodType<TargetDeploymentPublicEndpointTargetMachineAddresses, unknown>;
+export declare function targetDeploymentPublicEndpointTargetMachineAddressesFromJSON(jsonString: string): SafeParseResult<TargetDeploymentPublicEndpointTargetMachineAddresses, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentPublicEndpointTargetUnion$inboundSchema: z.ZodType<TargetDeploymentPublicEndpointTargetUnion, unknown>;
+export declare function targetDeploymentPublicEndpointTargetUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentPublicEndpointTargetUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentDomains$inboundSchema: z.ZodType<TargetDeploymentDomains, unknown>;
+export declare function targetDeploymentDomainsFromJSON(jsonString: string): SafeParseResult<TargetDeploymentDomains, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentDomainsUnion$inboundSchema: z.ZodType<TargetDeploymentDomainsUnion, unknown>;
+export declare function targetDeploymentDomainsUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentDomainsUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentEndpointAccess$inboundSchema: z.ZodEnum<typeof TargetDeploymentEndpointAccess>;
+/** @internal */
+export declare const TargetDeploymentHeartbeats$inboundSchema: z.ZodEnum<typeof TargetDeploymentHeartbeats>;
+/** @internal */
+export declare const TargetDeploymentCloud$inboundSchema: z.ZodType<TargetDeploymentCloud, unknown>;
+export declare function targetDeploymentCloudFromJSON(jsonString: string): SafeParseResult<TargetDeploymentCloud, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCloudUnion$inboundSchema: z.ZodType<TargetDeploymentCloudUnion, unknown>;
+export declare function targetDeploymentCloudUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentCloudUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentOwnership$inboundSchema: z.ZodEnum<typeof TargetDeploymentOwnership>;
+/** @internal */
+export declare const TargetDeploymentCluster$inboundSchema: z.ZodType<TargetDeploymentCluster, unknown>;
+export declare function targetDeploymentClusterFromJSON(jsonString: string): SafeParseResult<TargetDeploymentCluster, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentClusterUnion$inboundSchema: z.ZodType<TargetDeploymentClusterUnion, unknown>;
+export declare function targetDeploymentClusterUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentClusterUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCertificateNone2$inboundSchema: z.ZodType<TargetDeploymentCertificateNone2, unknown>;
+export declare function targetDeploymentCertificateNone2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentCertificateNone2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCertificateManagedTLSSecret2$inboundSchema: z.ZodType<TargetDeploymentCertificateManagedTLSSecret2, unknown>;
+export declare function targetDeploymentCertificateManagedTLSSecret2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentCertificateManagedTLSSecret2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCertificateAwsAcmArn2$inboundSchema: z.ZodType<TargetDeploymentCertificateAwsAcmArn2, unknown>;
+export declare function targetDeploymentCertificateAwsAcmArn2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentCertificateAwsAcmArn2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCertificateManagedAcmImport2$inboundSchema: z.ZodType<TargetDeploymentCertificateManagedAcmImport2, unknown>;
+export declare function targetDeploymentCertificateManagedAcmImport2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentCertificateManagedAcmImport2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCertificateTLSSecretRef2$inboundSchema: z.ZodType<TargetDeploymentCertificateTLSSecretRef2, unknown>;
+export declare function targetDeploymentCertificateTLSSecretRef2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentCertificateTLSSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCertificateUnion2$inboundSchema: z.ZodType<TargetDeploymentCertificateUnion2, unknown>;
+export declare function targetDeploymentCertificateUnion2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentCertificateUnion2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentModeCustom$inboundSchema: z.ZodEnum<typeof TargetDeploymentModeCustom>;
+/** @internal */
+export declare const TargetDeploymentProviderAzureApplicationGatewayForContainersEnum4$inboundSchema: z.ZodEnum<typeof TargetDeploymentProviderAzureApplicationGatewayForContainersEnum4>;
+/** @internal */
+export declare const TargetDeploymentProviderAzureApplicationGatewayForContainers4$inboundSchema: z.ZodType<TargetDeploymentProviderAzureApplicationGatewayForContainers4, unknown>;
+export declare function targetDeploymentProviderAzureApplicationGatewayForContainers4FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderAzureApplicationGatewayForContainers4, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderGkeGatewayEnum4$inboundSchema: z.ZodEnum<typeof TargetDeploymentProviderGkeGatewayEnum4>;
+/** @internal */
+export declare const TargetDeploymentProviderGkeGateway4$inboundSchema: z.ZodType<TargetDeploymentProviderGkeGateway4, unknown>;
+export declare function targetDeploymentProviderGkeGateway4FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderGkeGateway4, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderAwsAlbEnum4$inboundSchema: z.ZodEnum<typeof TargetDeploymentProviderAwsAlbEnum4>;
+/** @internal */
+export declare const TargetDeploymentProviderAwsAlb4$inboundSchema: z.ZodType<TargetDeploymentProviderAwsAlb4, unknown>;
+export declare function targetDeploymentProviderAwsAlb4FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderAwsAlb4, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderUnion4$inboundSchema: z.ZodType<TargetDeploymentProviderUnion4, unknown>;
+export declare function targetDeploymentProviderUnion4FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderUnion4, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentRouteGateway2$inboundSchema: z.ZodType<TargetDeploymentRouteGateway2, unknown>;
+export declare function targetDeploymentRouteGateway2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentRouteGateway2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderAzureApplicationGatewayForContainersEnum3$inboundSchema: z.ZodEnum<typeof TargetDeploymentProviderAzureApplicationGatewayForContainersEnum3>;
+/** @internal */
+export declare const TargetDeploymentProviderAzureApplicationGatewayForContainers3$inboundSchema: z.ZodType<TargetDeploymentProviderAzureApplicationGatewayForContainers3, unknown>;
+export declare function targetDeploymentProviderAzureApplicationGatewayForContainers3FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderAzureApplicationGatewayForContainers3, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderGkeGatewayEnum3$inboundSchema: z.ZodEnum<typeof TargetDeploymentProviderGkeGatewayEnum3>;
+/** @internal */
+export declare const TargetDeploymentProviderGkeGateway3$inboundSchema: z.ZodType<TargetDeploymentProviderGkeGateway3, unknown>;
+export declare function targetDeploymentProviderGkeGateway3FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderGkeGateway3, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderAwsAlbEnum3$inboundSchema: z.ZodEnum<typeof TargetDeploymentProviderAwsAlbEnum3>;
+/** @internal */
+export declare const TargetDeploymentProviderAwsAlb3$inboundSchema: z.ZodType<TargetDeploymentProviderAwsAlb3, unknown>;
+export declare function targetDeploymentProviderAwsAlb3FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderAwsAlb3, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderUnion3$inboundSchema: z.ZodType<TargetDeploymentProviderUnion3, unknown>;
+export declare function targetDeploymentProviderUnion3FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderUnion3, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentRouteIngress2$inboundSchema: z.ZodType<TargetDeploymentRouteIngress2, unknown>;
+export declare function targetDeploymentRouteIngress2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentRouteIngress2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentRouteUnion2$inboundSchema: z.ZodType<TargetDeploymentRouteUnion2, unknown>;
+export declare function targetDeploymentRouteUnion2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentRouteUnion2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentExposureCustom$inboundSchema: z.ZodType<TargetDeploymentExposureCustom, unknown>;
+export declare function targetDeploymentExposureCustomFromJSON(jsonString: string): SafeParseResult<TargetDeploymentExposureCustom, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCertificateNone1$inboundSchema: z.ZodType<TargetDeploymentCertificateNone1, unknown>;
+export declare function targetDeploymentCertificateNone1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentCertificateNone1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCertificateManagedTLSSecret1$inboundSchema: z.ZodType<TargetDeploymentCertificateManagedTLSSecret1, unknown>;
+export declare function targetDeploymentCertificateManagedTLSSecret1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentCertificateManagedTLSSecret1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCertificateAwsAcmArn1$inboundSchema: z.ZodType<TargetDeploymentCertificateAwsAcmArn1, unknown>;
+export declare function targetDeploymentCertificateAwsAcmArn1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentCertificateAwsAcmArn1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCertificateManagedAcmImport1$inboundSchema: z.ZodType<TargetDeploymentCertificateManagedAcmImport1, unknown>;
+export declare function targetDeploymentCertificateManagedAcmImport1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentCertificateManagedAcmImport1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCertificateTLSSecretRef1$inboundSchema: z.ZodType<TargetDeploymentCertificateTLSSecretRef1, unknown>;
+export declare function targetDeploymentCertificateTLSSecretRef1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentCertificateTLSSecretRef1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentCertificateUnion1$inboundSchema: z.ZodType<TargetDeploymentCertificateUnion1, unknown>;
+export declare function targetDeploymentCertificateUnion1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentCertificateUnion1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentModeGenerated$inboundSchema: z.ZodEnum<typeof TargetDeploymentModeGenerated>;
+/** @internal */
+export declare const TargetDeploymentProviderAzureApplicationGatewayForContainersEnum2$inboundSchema: z.ZodEnum<typeof TargetDeploymentProviderAzureApplicationGatewayForContainersEnum2>;
+/** @internal */
+export declare const TargetDeploymentProviderAzureApplicationGatewayForContainers2$inboundSchema: z.ZodType<TargetDeploymentProviderAzureApplicationGatewayForContainers2, unknown>;
+export declare function targetDeploymentProviderAzureApplicationGatewayForContainers2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderAzureApplicationGatewayForContainers2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderGkeGatewayEnum2$inboundSchema: z.ZodEnum<typeof TargetDeploymentProviderGkeGatewayEnum2>;
+/** @internal */
+export declare const TargetDeploymentProviderGkeGateway2$inboundSchema: z.ZodType<TargetDeploymentProviderGkeGateway2, unknown>;
+export declare function targetDeploymentProviderGkeGateway2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderGkeGateway2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderAwsAlbEnum2$inboundSchema: z.ZodEnum<typeof TargetDeploymentProviderAwsAlbEnum2>;
+/** @internal */
+export declare const TargetDeploymentProviderAwsAlb2$inboundSchema: z.ZodType<TargetDeploymentProviderAwsAlb2, unknown>;
+export declare function targetDeploymentProviderAwsAlb2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderAwsAlb2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderUnion2$inboundSchema: z.ZodType<TargetDeploymentProviderUnion2, unknown>;
+export declare function targetDeploymentProviderUnion2FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderUnion2, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentRouteGateway1$inboundSchema: z.ZodType<TargetDeploymentRouteGateway1, unknown>;
+export declare function targetDeploymentRouteGateway1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentRouteGateway1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderAzureApplicationGatewayForContainersEnum1$inboundSchema: z.ZodEnum<typeof TargetDeploymentProviderAzureApplicationGatewayForContainersEnum1>;
+/** @internal */
+export declare const TargetDeploymentProviderAzureApplicationGatewayForContainers1$inboundSchema: z.ZodType<TargetDeploymentProviderAzureApplicationGatewayForContainers1, unknown>;
+export declare function targetDeploymentProviderAzureApplicationGatewayForContainers1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderAzureApplicationGatewayForContainers1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderGkeGatewayEnum1$inboundSchema: z.ZodEnum<typeof TargetDeploymentProviderGkeGatewayEnum1>;
+/** @internal */
+export declare const TargetDeploymentProviderGkeGateway1$inboundSchema: z.ZodType<TargetDeploymentProviderGkeGateway1, unknown>;
+export declare function targetDeploymentProviderGkeGateway1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderGkeGateway1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderAwsAlbEnum1$inboundSchema: z.ZodEnum<typeof TargetDeploymentProviderAwsAlbEnum1>;
+/** @internal */
+export declare const TargetDeploymentProviderAwsAlb1$inboundSchema: z.ZodType<TargetDeploymentProviderAwsAlb1, unknown>;
+export declare function targetDeploymentProviderAwsAlb1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderAwsAlb1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentProviderUnion1$inboundSchema: z.ZodType<TargetDeploymentProviderUnion1, unknown>;
+export declare function targetDeploymentProviderUnion1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentProviderUnion1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentRouteIngress1$inboundSchema: z.ZodType<TargetDeploymentRouteIngress1, unknown>;
+export declare function targetDeploymentRouteIngress1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentRouteIngress1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentRouteUnion1$inboundSchema: z.ZodType<TargetDeploymentRouteUnion1, unknown>;
+export declare function targetDeploymentRouteUnion1FromJSON(jsonString: string): SafeParseResult<TargetDeploymentRouteUnion1, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentExposureGenerated$inboundSchema: z.ZodType<TargetDeploymentExposureGenerated, unknown>;
+export declare function targetDeploymentExposureGeneratedFromJSON(jsonString: string): SafeParseResult<TargetDeploymentExposureGenerated, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentModeDisabled$inboundSchema: z.ZodEnum<typeof TargetDeploymentModeDisabled>;
+/** @internal */
+export declare const TargetDeploymentExposureDisabled$inboundSchema: z.ZodType<TargetDeploymentExposureDisabled, unknown>;
+export declare function targetDeploymentExposureDisabledFromJSON(jsonString: string): SafeParseResult<TargetDeploymentExposureDisabled, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentExposureUnion$inboundSchema: z.ZodType<TargetDeploymentExposureUnion, unknown>;
+export declare function targetDeploymentExposureUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentExposureUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentKubernetes$inboundSchema: z.ZodType<TargetDeploymentKubernetes, unknown>;
+export declare function targetDeploymentKubernetesFromJSON(jsonString: string): SafeParseResult<TargetDeploymentKubernetes, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentKubernetesUnion$inboundSchema: z.ZodType<TargetDeploymentKubernetesUnion, unknown>;
+export declare function targetDeploymentKubernetesUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentKubernetesUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentTypeByoVnetAzure$inboundSchema: z.ZodEnum<typeof TargetDeploymentTypeByoVnetAzure>;
+/** @internal */
+export declare const TargetDeploymentNetworkByoVnetAzure$inboundSchema: z.ZodType<TargetDeploymentNetworkByoVnetAzure, unknown>;
+export declare function targetDeploymentNetworkByoVnetAzureFromJSON(jsonString: string): SafeParseResult<TargetDeploymentNetworkByoVnetAzure, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentTypeByoVpcGcp$inboundSchema: z.ZodEnum<typeof TargetDeploymentTypeByoVpcGcp>;
+/** @internal */
+export declare const TargetDeploymentNetworkByoVpcGcp$inboundSchema: z.ZodType<TargetDeploymentNetworkByoVpcGcp, unknown>;
+export declare function targetDeploymentNetworkByoVpcGcpFromJSON(jsonString: string): SafeParseResult<TargetDeploymentNetworkByoVpcGcp, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentTypeByoVpcAws$inboundSchema: z.ZodEnum<typeof TargetDeploymentTypeByoVpcAws>;
+/** @internal */
+export declare const TargetDeploymentNetworkByoVpcAws$inboundSchema: z.ZodType<TargetDeploymentNetworkByoVpcAws, unknown>;
+export declare function targetDeploymentNetworkByoVpcAwsFromJSON(jsonString: string): SafeParseResult<TargetDeploymentNetworkByoVpcAws, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentTypeCreate$inboundSchema: z.ZodEnum<typeof TargetDeploymentTypeCreate>;
+/** @internal */
+export declare const TargetDeploymentNetworkCreate$inboundSchema: z.ZodType<TargetDeploymentNetworkCreate, unknown>;
+export declare function targetDeploymentNetworkCreateFromJSON(jsonString: string): SafeParseResult<TargetDeploymentNetworkCreate, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentTypeUseDefault$inboundSchema: z.ZodEnum<typeof TargetDeploymentTypeUseDefault>;
+/** @internal */
+export declare const TargetDeploymentNetworkUseDefault$inboundSchema: z.ZodType<TargetDeploymentNetworkUseDefault, unknown>;
+export declare function targetDeploymentNetworkUseDefaultFromJSON(jsonString: string): SafeParseResult<TargetDeploymentNetworkUseDefault, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentNetworkUnion$inboundSchema: z.ZodType<TargetDeploymentNetworkUnion, unknown>;
+export declare function targetDeploymentNetworkUnionFromJSON(jsonString: string): SafeParseResult<TargetDeploymentNetworkUnion, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentSetupManagement$inboundSchema: z.ZodEnum<typeof TargetDeploymentSetupManagement>;
+/** @internal */
+export declare const TargetDeploymentTelemetry$inboundSchema: z.ZodEnum<typeof TargetDeploymentTelemetry>;
+/** @internal */
+export declare const TargetDeploymentUpdates$inboundSchema: z.ZodEnum<typeof TargetDeploymentUpdates>;
+/** @internal */
+export declare const TargetDeploymentStackSettings$inboundSchema: z.ZodType<TargetDeploymentStackSettings, unknown>;
+export declare function targetDeploymentStackSettingsFromJSON(jsonString: string): SafeParseResult<TargetDeploymentStackSettings, SDKValidationError>;
+/** @internal */
+export declare const TargetDeploymentVolumeRestore$inboundSchema: z.ZodType<TargetDeploymentVolumeRestore, unknown>;
+export declare function targetDeploymentVolumeRestoreFromJSON(jsonString: string): SafeParseResult<TargetDeploymentVolumeRestore, SDKValidationError>;
+//# sourceMappingURL=targetdeploymentvolumerestore.d.ts.map