@alienplatform/platform-api 3.3.19 → 3.3.21

package/src/models/deploymentinfo.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
@@ -28,24 +29,10 @@ import {
   SupportedCloudRegions$inboundSchema,
 } from "./supportedcloudregions.js";
 
-/**
- * Type of token used to authenticate this request
- */
-export const DeploymentInfoTokenType = {
-  Deployment: "deployment",
-  DeploymentGroup: "deployment-group",
-} as const;
-/**
- * Type of token used to authenticate this request
- */
-export type DeploymentInfoTokenType = ClosedEnum<
-  typeof DeploymentInfoTokenType
->;
-
 /**
  * Represents the target cloud platform.
  */
-export const DeploymentInfoDeploymentPlatform = {
+export const SetupUpdatePlatform = {
   Aws: "aws",
   Gcp: "gcp",
   Azure: "azure",
@@ -57,719 +44,3877 @@ export const DeploymentInfoDeploymentPlatform = {
 /**
  * Represents the target cloud platform.
  */
-export type DeploymentInfoDeploymentPlatform = ClosedEnum<
-  typeof DeploymentInfoDeploymentPlatform
+export type SetupUpdatePlatform = ClosedEnum<typeof SetupUpdatePlatform>;
+
+export const DeploymentInfoSetupMethod = {
+  Cloudformation: "cloudformation",
+  GoogleOauth: "google-oauth",
+  Terraform: "terraform",
+  Helm: "helm",
+  Cli: "cli",
+  Manual: "manual",
+} as const;
+export type DeploymentInfoSetupMethod = ClosedEnum<
+  typeof DeploymentInfoSetupMethod
 >;
 
 /**
- * Deployment details (present when using a deployment-scoped token)
+ * Failure-domain policy selected for a compute pool.
  */
-export type DeploymentInfoDeployment = {
-  name: string;
+export type DeploymentInfoFailureDomains2 = {
   /**
-   * Represents the target cloud platform.
+   * Concrete provider domains selected during setup.
+   *
+   * @remarks
+   * Empty delegates deterministic selection to the provider setup implementation.
    */
-  platform: DeploymentInfoDeploymentPlatform;
+  selectedFailureDomains?: Array<string> | undefined;
+  /**
+   * Number of distinct failure domains across which new stateful replicas may be spread.
+   */
+  spread: number;
+};
+
+export type DeploymentInfoFailureDomainsUnion2 =
+  | DeploymentInfoFailureDomains2
+  | any;
+
+export type DeploymentInfoPoolsAutoscale = {
+  failureDomains?: DeploymentInfoFailureDomains2 | any | null | undefined;
+  /**
+   * Provider machine type selected for this deployment.
+   */
+  machine?: string | null | undefined;
+  /**
+   * Maximum machine count.
+   */
+  max: number;
+  /**
+   * Minimum machine count.
+   */
+  min: number;
+  mode: "autoscale";
 };
 
 /**
- * Deployment group details (present when using a deployment-group token)
+ * Failure-domain policy selected for a compute pool.
  */
-export type DeploymentInfoDeploymentGroup = {
+export type DeploymentInfoFailureDomains1 = {
   /**
-   * Unique identifier for the deployment group.
+   * Concrete provider domains selected during setup.
+   *
+   * @remarks
+   * Empty delegates deterministic selection to the provider setup implementation.
    */
-  id: string;
-  name: string;
-  pinnedSubdomain: string | null;
+  selectedFailureDomains?: Array<string> | undefined;
+  /**
+   * Number of distinct failure domains across which new stateful replicas may be spread.
+   */
+  spread: number;
 };
 
-export type DeploymentInfoWorkspace = {
-  id: string;
-  name: string;
-  avatarUrl?: string | null | undefined;
+export type DeploymentInfoFailureDomainsUnion1 =
+  | DeploymentInfoFailureDomains1
+  | any;
+
+export type DeploymentInfoPoolsFixed = {
+  failureDomains?: DeploymentInfoFailureDomains1 | any | null | undefined;
+  /**
+   * Provider machine type selected for this deployment.
+   */
+  machine?: string | null | undefined;
+  /**
+   * Number of machines to run.
+   */
+  machines: number;
+  mode: "fixed";
 };
 
-export type Portal = {
-  appearance: DeploymentPortalAppearance;
+/**
+ * User-selected deployment settings for one compute pool.
+ */
+export type DeploymentInfoPoolsUnion =
+  | DeploymentInfoPoolsFixed
+  | DeploymentInfoPoolsAutoscale;
+
+/**
+ * Deployment-time compute choices for Alien-managed compute pools.
+ *
+ * @remarks
+ *
+ * Application source declares portable pool requirements. This settings
+ * object stores the concrete choices made for one deployment, such as the
+ * provider machine type and selected machine counts.
+ */
+export type DeploymentInfoCompute = {
+  /**
+   * Selected compute choices keyed by pool ID.
+   */
+  pools?: {
+    [k: string]: DeploymentInfoPoolsFixed | DeploymentInfoPoolsAutoscale;
+  } | undefined;
 };
 
+export type DeploymentInfoComputeUnion = DeploymentInfoCompute | any;
+
 /**
- * Represents the target cloud platform.
+ * Deployment model: how updates are delivered to the remote environment.
  */
-export const StackSummaryPlatform = {
-  Aws: "aws",
-  Gcp: "gcp",
-  Azure: "azure",
-  Kubernetes: "kubernetes",
-  Machines: "machines",
-  Local: "local",
-  Test: "test",
+export const DeploymentInfoDeploymentModel = {
+  Push: "push",
+  Pull: "pull",
 } as const;
 /**
- * Represents the target cloud platform.
+ * Deployment model: how updates are delivered to the remote environment.
  */
-export type StackSummaryPlatform = ClosedEnum<typeof StackSummaryPlatform>;
+export type DeploymentInfoDeploymentModel = ClosedEnum<
+  typeof DeploymentInfoDeploymentModel
+>;
 
-export type ResourceCounts = {
-  workers: number;
-  containers: number;
+export type DeploymentInfoAws = {
+  certificateArn: string;
+};
+
+export type DeploymentInfoAwsUnion = DeploymentInfoAws | any;
+
+export type DeploymentInfoAzure = {
+  keyVaultCertificateId: string;
+  keyVaultResourceId?: string | null | undefined;
+};
+
+export type DeploymentInfoAzureUnion = DeploymentInfoAzure | any;
+
+export type DeploymentInfoGcp = {
+  certificateName: string;
+};
+
+export type DeploymentInfoGcpUnion = DeploymentInfoGcp | any;
+
+/**
+ * Namespace-scoped Kubernetes TLS Secret reference.
+ */
+export type DeploymentInfoTlsSecretRef = {
   /**
-   * Daemon resources that run on managed runtime machines
+   * Secret namespace. Defaults to the release namespace when omitted.
    */
-  daemons?: number | undefined;
+  namespace?: string | null | undefined;
   /**
-   * Resources that declare managed public HTTPS endpoint setup
+   * Secret name.
    */
-  publicHttpsEndpoints: number;
+  secretName: string;
+};
+
+export type DeploymentInfoDomainsKubernetes = {
   /**
-   * Storage, queue, KV, vault, database, or cache resources that Kubernetes needs Terraform to provision
+   * Namespace-scoped Kubernetes TLS Secret reference.
    */
-  externalInfra: number;
-  total: number;
+  tlsSecretRef: DeploymentInfoTlsSecretRef;
 };
 
-export type PublicEndpoint = {
-  resourceId: string;
-  endpointName: string;
-  hostLabel: string;
-  wildcardSubdomains: boolean;
+export type DeploymentInfoDomainsKubernetesUnion =
+  | DeploymentInfoDomainsKubernetes
+  | any;
+
+/**
+ * Platform-specific certificate references for custom domains.
+ */
+export type DeploymentInfoDomainsCertificate = {
+  aws?: DeploymentInfoAws | any | null | undefined;
+  azure?: DeploymentInfoAzure | any | null | undefined;
+  gcp?: DeploymentInfoGcp | any | null | undefined;
+  kubernetes?: DeploymentInfoDomainsKubernetes | any | null | undefined;
 };
 
-export type StackSummary = {
-  /**
-   * Platforms supported by the active release
-   */
-  platforms: Array<StackSummaryPlatform>;
+/**
+ * Custom domain configuration for a single resource.
+ */
+export type DeploymentInfoCustomDomains = {
   /**
-   * Whether the stack contains resources that require cloud VPC networking
+   * Platform-specific certificate references for custom domains.
    */
-  requiresNetwork: boolean;
+  certificate: DeploymentInfoDomainsCertificate;
   /**
-   * Whether this release offers one remotely accessible AI resource
+   * Fully qualified domain name to use.
    */
-  customerModels: boolean;
-  resourceCounts: ResourceCounts;
+  domain: string;
+};
+
+export const SetupUpdateModeLoadBalancer = {
+  LoadBalancer: "loadBalancer",
+} as const;
+export type SetupUpdateModeLoadBalancer = ClosedEnum<
+  typeof SetupUpdateModeLoadBalancer
+>;
+
+export type DeploymentInfoPublicEndpointTargetLoadBalancer = {
   /**
-   * Public endpoints declared by the active release stack
+   * DNS name or URL for the external load balancer.
    */
-  publicEndpoints: Array<PublicEndpoint>;
+  cnameTarget: string;
+  mode: SetupUpdateModeLoadBalancer;
 };
 
-/**
- * Parent domain for generated deployment URLs. Chosen public subdomains are only allowed when isSystem is false.
- */
-export type GeneratedDomain = {
-  domain: string;
-  isSystem: boolean;
+export const SetupUpdateModeMachineAddresses = {
+  MachineAddresses: "machineAddresses",
+} as const;
+export type SetupUpdateModeMachineAddresses = ClosedEnum<
+  typeof SetupUpdateModeMachineAddresses
+>;
+
+export type DeploymentInfoPublicEndpointTargetMachineAddresses = {
+  mode: SetupUpdateModeMachineAddresses;
 };
 
-export type DeploymentInfoProject = {
-  name: string;
-  portal: Portal;
-  stackSummary?: StackSummary | null | undefined;
+export type DeploymentInfoPublicEndpointTargetUnion =
+  | DeploymentInfoPublicEndpointTargetLoadBalancer
+  | DeploymentInfoPublicEndpointTargetMachineAddresses
+  | any;
+
+/**
+ * Domain configuration for the stack.
+ *
+ * @remarks
+ *
+ * When `custom_domains` is set, the specified resources use customer-provided
+ * domains and certificates. Otherwise, Alien auto-generates domains.
+ */
+export type DeploymentInfoDomains = {
   /**
-   * Parent domain for generated deployment URLs. Chosen public subdomains are only allowed when isSystem is false.
+   * Custom domain configuration per resource ID.
    */
-  generatedDomain?: GeneratedDomain | null | undefined;
+  customDomains?:
+    | { [k: string]: DeploymentInfoCustomDomains }
+    | null
+    | undefined;
+  publicEndpointTarget?:
+    | DeploymentInfoPublicEndpointTargetLoadBalancer
+    | DeploymentInfoPublicEndpointTargetMachineAddresses
+    | any
+    | null
+    | undefined;
 };
 
+export type DeploymentInfoDomainsUnion = DeploymentInfoDomains | any;
+
 /**
- * Status of a package build
+ * External bindings for pre-existing infrastructure.
+ *
+ * @remarks
+ * Allows using existing resources (MinIO, Redis, shared Container Apps
+ * Environment, etc.) instead of having Alien provision them.
+ * Required for Kubernetes platform, optional for cloud platforms.
  */
-export const CliStatus = {
-  Pending: "pending",
-  Building: "building",
-  Ready: "ready",
-  Failed: "failed",
-  Canceled: "canceled",
+export type DeploymentInfoExternalBindings = {};
+
+/**
+ * How heartbeat health checks are handled.
+ */
+export const DeploymentInfoHeartbeats = {
+  Off: "off",
+  On: "on",
 } as const;
 /**
- * Status of a package build
+ * How heartbeat health checks are handled.
  */
-export type CliStatus = ClosedEnum<typeof CliStatus>;
+export type DeploymentInfoHeartbeats = ClosedEnum<
+  typeof DeploymentInfoHeartbeats
+>;
 
 /**
- * Information about a single binary artifact
+ * Optional provider-specific identity for a cloud-backed Kubernetes cluster.
  */
-export type DeploymentInfoBinaries = {
-  /**
-   * SHA256 checksum
-   */
-  sha256: string;
-  /**
-   * File size in bytes
-   */
-  size: number;
-  /**
-   * Download URL for the binary
-   */
-  url: string;
+export type DeploymentInfoCloud = {
+  accountId?: string | null | undefined;
+  clusterId?: string | null | undefined;
+  clusterName?: string | null | undefined;
+  projectId?: string | null | undefined;
+  region?: string | null | undefined;
+  resourceGroup?: string | null | undefined;
+  subscriptionId?: string | null | undefined;
 };
 
+export type DeploymentInfoCloudUnion = DeploymentInfoCloud | any;
+
 /**
- * Source provenance for a generated CLI package.
+ * Ownership model for the Kubernetes cluster.
  */
-export type DeploymentInfoBuildInfo = {
+export const DeploymentInfoOwnership = {
+  Managed: "managed",
+  Existing: "existing",
+  External: "external",
+} as const;
+/**
+ * Ownership model for the Kubernetes cluster.
+ */
+export type DeploymentInfoOwnership = ClosedEnum<
+  typeof DeploymentInfoOwnership
+>;
+
+/**
+ * Kubernetes cluster setup settings.
+ */
+export type DeploymentInfoCluster = {
+  cloud?: DeploymentInfoCloud | any | null | undefined;
   /**
-   * Alien source commit used to build the source CLI and agent binaries.
+   * Namespace where the Alien chart and application resources run.
    */
-  alienSha: string;
+  namespace?: string | null | undefined;
   /**
-   * Compute backend source revision used by optional package extensions, if applicable.
+   * Ownership model for the Kubernetes cluster.
    */
-  horizonSha: string;
+  ownership: DeploymentInfoOwnership;
+};
+
+export type DeploymentInfoClusterUnion = DeploymentInfoCluster | any;
+
+export type DeploymentInfoCertificateNone2 = {
+  mode: "none";
+};
+
+export type DeploymentInfoCertificateManagedTLSSecret2 = {
+  mode: "managedTlsSecret";
   /**
-   * Machine runtime release manifest embedded into the generated CLI.
+   * Secret name template. Runtime may substitute resource/deployment tokens.
    */
-  machineBundleManifestUrl?: string | null | undefined;
+  secretNameTemplate: string;
+};
+
+export type DeploymentInfoCertificateAwsAcmArn2 = {
   /**
-   * Source revision used to build the package service and optional extensions.
+   * Existing ACM certificate ARN.
    */
-  platformSha: string;
+  certificateArn: string;
+  mode: "awsAcmArn";
+};
+
+export type DeploymentInfoCertificateManagedAcmImport2 = {
+  mode: "managedAcmImport";
   /**
-   * SHA256 checksum of the source runtime helper binary shipped with the CLI package, when present.
+   * ACM region. Defaults to the deployment region when omitted.
    */
-  sourceAgentBinarySha256?: string | null | undefined;
+  region?: string | null | undefined;
   /**
-   * SHA256 checksum of the source deploy CLI binary before white-label config is appended.
+   * Tags applied to runtime-imported ACM certificates.
    */
-  sourceCliBinarySha256: string;
+  tags?: { [k: string]: string } | undefined;
 };
 
 /**
- * Outputs from a CLI package build
+ * Namespace-scoped Kubernetes TLS Secret reference.
  */
-export type CliOutputs = {
+export type DeploymentInfoCertificateTLSSecretRef2 = {
   /**
-   * Binary information for each target platform
+   * Secret namespace. Defaults to the release namespace when omitted.
    */
-  binaries: { [k: string]: DeploymentInfoBinaries };
+  namespace?: string | null | undefined;
   /**
-   * Source provenance for a generated CLI package.
+   * Secret name.
    */
-  buildInfo: DeploymentInfoBuildInfo;
+  secretName: string;
+  mode: "tlsSecretRef";
 };
 
 /**
- * Install script URLs for each OS
+ * Certificate publication or reference mode for Kubernetes public endpoints.
  */
-export type InstallScripts = {
-  windows: string;
-  mac: string;
-  linux: string;
-};
+export type DeploymentInfoCertificateUnion2 =
+  | DeploymentInfoCertificateTLSSecretRef2
+  | DeploymentInfoCertificateManagedAcmImport2
+  | DeploymentInfoCertificateAwsAcmArn2
+  | DeploymentInfoCertificateManagedTLSSecret2
+  | DeploymentInfoCertificateNone2;
+
+export const SetupUpdateModeCustom = {
+  Custom: "custom",
+} as const;
+export type SetupUpdateModeCustom = ClosedEnum<typeof SetupUpdateModeCustom>;
 
-export type DeploymentInfoCli = {
+export const SetupUpdateProviderAzureApplicationGatewayForContainersEnum4 = {
+  AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers",
+} as const;
+export type SetupUpdateProviderAzureApplicationGatewayForContainersEnum4 =
+  ClosedEnum<
+    typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum4
+  >;
+
+export type ProviderSetupUpdateAzureApplicationGatewayForContainers4 = {
   /**
-   * Status of a package build
+   * Optional ALB name when using BYO Application Gateway resources.
    */
-  status: CliStatus;
+  albName?: string | null | undefined;
   /**
-   * CLI command name to use in install instructions
+   * Optional ALB namespace when using BYO Application Gateway resources.
    */
-  commandName: string;
-  version?: string | undefined;
+  albNamespace?: string | null | undefined;
   /**
-   * Outputs from a CLI package build
+   * Public or internal frontend exposure.
    */
-  outputs?: CliOutputs | undefined;
-  error?: any | null | undefined;
+  frontend: string;
+  provider: SetupUpdateProviderAzureApplicationGatewayForContainersEnum4;
+};
+
+export const SetupUpdateProviderGkeGatewayEnum4 = {
+  GkeGateway: "gkeGateway",
+} as const;
+export type SetupUpdateProviderGkeGatewayEnum4 = ClosedEnum<
+  typeof SetupUpdateProviderGkeGatewayEnum4
+>;
+
+export type ProviderSetupUpdateGkeGateway4 = {
+  provider: SetupUpdateProviderGkeGatewayEnum4;
   /**
-   * Install script URLs for each OS
+   * Optional static address name for the Gateway frontend.
    */
-  installScripts: InstallScripts;
+  staticAddressName?: string | null | undefined;
 };
 
-/**
- * Status of a package build
- */
-export const CloudformationStatus = {
-  Pending: "pending",
-  Building: "building",
-  Ready: "ready",
-  Failed: "failed",
-  Canceled: "canceled",
+export const SetupUpdateProviderAwsAlbEnum4 = {
+  AwsAlb: "awsAlb",
 } as const;
-/**
- * Status of a package build
- */
-export type CloudformationStatus = ClosedEnum<typeof CloudformationStatus>;
+export type SetupUpdateProviderAwsAlbEnum4 = ClosedEnum<
+  typeof SetupUpdateProviderAwsAlbEnum4
+>;
+
+export type ProviderSetupUpdateAwsAlb4 = {
+  /**
+   * Optional ALB IP address type, such as `dualstack`.
+   */
+  ipAddressType?: string | null | undefined;
+  provider: SetupUpdateProviderAwsAlbEnum4;
+  /**
+   * Internet-facing or internal ALB scheme.
+   */
+  scheme: string;
+  /**
+   * Explicit subnet IDs when the profile cannot rely on controller discovery.
+   */
+  subnetIds?: Array<string> | undefined;
+  /**
+   * ALB target type, usually `ip`.
+   */
+  targetType: string;
+};
+
+export type SetupUpdateProviderUnion4 =
+  | ProviderSetupUpdateAwsAlb4
+  | ProviderSetupUpdateAzureApplicationGatewayForContainers4
+  | ProviderSetupUpdateGkeGateway4
+  | any;
 
 /**
- * Information about a single CloudFormation template package for one target.
+ * Shared Gateway API route profile values.
  */
-export type CloudformationTargets = {
+export type DeploymentInfoRouteGateway2 = {
   /**
-   * AWS Console quick-launch URL
+   * Annotations applied to route objects.
    */
-  launchStackUrl: string;
+  annotations?: { [k: string]: string } | undefined;
   /**
-   * SHA256 checksum of the template
+   * Route controller identifier, for example a cloud Gateway controller.
    */
-  sha256: string;
+  controller?: string | null | undefined;
   /**
-   * Template size in bytes
+   * GatewayClass selected for generated Gateways.
    */
-  size: number;
+  gatewayClassName: string;
   /**
-   * S3 URL to the CloudFormation stack policy
+   * Labels applied to route objects.
    */
-  stackPolicyUrl: string;
+  labels?: { [k: string]: string } | undefined;
   /**
-   * CloudFormation target (aws, eks)
+   * Listener port, usually 443.
    */
-  target: string;
+  listenerPort: number;
+  provider?:
+    | ProviderSetupUpdateAwsAlb4
+    | ProviderSetupUpdateAzureApplicationGatewayForContainers4
+    | ProviderSetupUpdateGkeGateway4
+    | any
+    | null
+    | undefined;
+  routeApi: "gateway";
+};
+
+export const SetupUpdateProviderAzureApplicationGatewayForContainersEnum3 = {
+  AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers",
+} as const;
+export type SetupUpdateProviderAzureApplicationGatewayForContainersEnum3 =
+  ClosedEnum<
+    typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum3
+  >;
+
+export type ProviderSetupUpdateAzureApplicationGatewayForContainers3 = {
   /**
-   * S3 URL to the CloudFormation template
+   * Optional ALB name when using BYO Application Gateway resources.
    */
-  templateUrl: string;
+  albName?: string | null | undefined;
+  /**
+   * Optional ALB namespace when using BYO Application Gateway resources.
+   */
+  albNamespace?: string | null | undefined;
+  /**
+   * Public or internal frontend exposure.
+   */
+  frontend: string;
+  provider: SetupUpdateProviderAzureApplicationGatewayForContainersEnum3;
 };
 
-/**
- * Outputs from a CloudFormation package build.
- */
-export type CloudformationOutputs = {
+export const SetupUpdateProviderGkeGatewayEnum3 = {
+  GkeGateway: "gkeGateway",
+} as const;
+export type SetupUpdateProviderGkeGatewayEnum3 = ClosedEnum<
+  typeof SetupUpdateProviderGkeGatewayEnum3
+>;
+
+export type ProviderSetupUpdateGkeGateway3 = {
+  provider: SetupUpdateProviderGkeGatewayEnum3;
   /**
-   * Template artifacts by CloudFormation target.
+   * Optional static address name for the Gateway frontend.
    */
-  targets: { [k: string]: CloudformationTargets };
+  staticAddressName?: string | null | undefined;
 };
 
-export const DeploymentInfoMode = {
-  Auto: "auto",
-  Outputs: "outputs",
+export const SetupUpdateProviderAwsAlbEnum3 = {
+  AwsAlb: "awsAlb",
 } as const;
-export type DeploymentInfoMode = ClosedEnum<typeof DeploymentInfoMode>;
+export type SetupUpdateProviderAwsAlbEnum3 = ClosedEnum<
+  typeof SetupUpdateProviderAwsAlbEnum3
+>;
 
-export type DeploymentInfoCloudformation = {
+export type ProviderSetupUpdateAwsAlb3 = {
   /**
-   * Status of a package build
+   * Optional ALB IP address type, such as `dualstack`.
    */
-  status: CloudformationStatus;
-  version?: string | undefined;
+  ipAddressType?: string | null | undefined;
+  provider: SetupUpdateProviderAwsAlbEnum3;
   /**
-   * Outputs from a CloudFormation package build.
+   * Internet-facing or internal ALB scheme.
    */
-  outputs?: CloudformationOutputs | undefined;
-  error?: any | null | undefined;
-  mode: DeploymentInfoMode;
+  scheme: string;
   /**
-   * CloudFormation launch URL
+   * Explicit subnet IDs when the profile cannot rely on controller discovery.
    */
-  launchUrl: string;
-  outputsSchema?: any | null | undefined;
+  subnetIds?: Array<string> | undefined;
+  /**
+   * ALB target type, usually `ip`.
+   */
+  targetType: string;
 };
 
+export type SetupUpdateProviderUnion3 =
+  | ProviderSetupUpdateAwsAlb3
+  | ProviderSetupUpdateAzureApplicationGatewayForContainers3
+  | ProviderSetupUpdateGkeGateway3
+  | any;
+
 /**
- * Status of a package build
- */
-export const TerraformStatus = {
-  Pending: "pending",
-  Building: "building",
-  Ready: "ready",
-  Failed: "failed",
-  Canceled: "canceled",
-} as const;
-/**
- * Status of a package build
+ * Shared Ingress route profile values.
  */
-export type TerraformStatus = ClosedEnum<typeof TerraformStatus>;
+export type DeploymentInfoRouteIngress2 = {
+  /**
+   * Annotations applied to route objects.
+   */
+  annotations?: { [k: string]: string } | undefined;
+  /**
+   * Route controller identifier, for example `eks.amazonaws.com/alb`.
+   */
+  controller?: string | null | undefined;
+  /**
+   * `spec.ingressClassName` for generated Ingresses.
+   */
+  ingressClassName: string;
+  /**
+   * Labels applied to route objects.
+   */
+  labels?: { [k: string]: string } | undefined;
+  provider?:
+    | ProviderSetupUpdateAwsAlb3
+    | ProviderSetupUpdateAzureApplicationGatewayForContainers3
+    | ProviderSetupUpdateGkeGateway3
+    | any
+    | null
+    | undefined;
+  routeApi: "ingress";
+};
 
 /**
- * Information about a single Terraform module package for one target.
+ * Kubernetes route API selected for public endpoints.
  */
-export type DeploymentInfoModules = {
+export type DeploymentInfoRouteUnion2 =
+  | DeploymentInfoRouteIngress2
+  | DeploymentInfoRouteGateway2;
+
+export type DeploymentInfoExposureCustom = {
   /**
-   * Download URL for the module archive
+   * Certificate publication or reference mode for Kubernetes public endpoints.
    */
-  downloadUrl: string;
+  certificate:
+    | DeploymentInfoCertificateTLSSecretRef2
+    | DeploymentInfoCertificateManagedAcmImport2
+    | DeploymentInfoCertificateAwsAcmArn2
+    | DeploymentInfoCertificateManagedTLSSecret2
+    | DeploymentInfoCertificateNone2;
   /**
-   * Filename of the module archive
+   * Hostname routed by the Kubernetes public endpoint.
    */
-  filename: string;
+  domain: string;
+  mode: SetupUpdateModeCustom;
   /**
-   * SHA256 checksum of the archive
+   * Kubernetes route API selected for public endpoints.
    */
-  shasum: string;
+  route: DeploymentInfoRouteIngress2 | DeploymentInfoRouteGateway2;
+};
+
+export type DeploymentInfoCertificateNone1 = {
+  mode: "none";
+};
+
+export type DeploymentInfoCertificateManagedTLSSecret1 = {
+  mode: "managedTlsSecret";
   /**
-   * Size of the archive in bytes
+   * Secret name template. Runtime may substitute resource/deployment tokens.
    */
-  size: number;
+  secretNameTemplate: string;
+};
+
+export type DeploymentInfoCertificateAwsAcmArn1 = {
   /**
-   * Terraform module source (hostname/namespace/name/provider, without scheme)
+   * Existing ACM certificate ARN.
    */
-  source: string;
+  certificateArn: string;
+  mode: "awsAcmArn";
+};
+
+export type DeploymentInfoCertificateManagedAcmImport1 = {
+  mode: "managedAcmImport";
   /**
-   * Terraform module target (aws, gcp, azure, eks, gke, aks)
+   * ACM region. Defaults to the deployment region when omitted.
    */
-  target: string;
+  region?: string | null | undefined;
   /**
-   * Terraform input variables exposed by this module.
+   * Tags applied to runtime-imported ACM certificates.
    */
-  variables?: Array<string> | undefined;
+  tags?: { [k: string]: string } | undefined;
 };
 
 /**
- * GPG public key for Terraform provider signature verification
+ * Namespace-scoped Kubernetes TLS Secret reference.
  */
-export type DeploymentInfoGpgPublicKey = {
+export type DeploymentInfoCertificateTLSSecretRef1 = {
   /**
-   * ASCII-armored public key
+   * Secret namespace. Defaults to the release namespace when omitted.
    */
-  asciiArmor: string;
+  namespace?: string | null | undefined;
   /**
-   * GPG key ID
+   * Secret name.
    */
-  keyId: string;
+  secretName: string;
+  mode: "tlsSecretRef";
 };
 
 /**
- * Information about a single Terraform provider package for a specific platform
+ * Certificate publication or reference mode for Kubernetes public endpoints.
  */
-export type DeploymentInfoPlatforms = {
+export type DeploymentInfoCertificateUnion1 =
+  | DeploymentInfoCertificateTLSSecretRef1
+  | DeploymentInfoCertificateManagedAcmImport1
+  | DeploymentInfoCertificateAwsAcmArn1
+  | DeploymentInfoCertificateManagedTLSSecret1
+  | DeploymentInfoCertificateNone1;
+
+export const SetupUpdateModeGenerated = {
+  Generated: "generated",
+} as const;
+export type SetupUpdateModeGenerated = ClosedEnum<
+  typeof SetupUpdateModeGenerated
+>;
+
+export const SetupUpdateProviderAzureApplicationGatewayForContainersEnum2 = {
+  AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers",
+} as const;
+export type SetupUpdateProviderAzureApplicationGatewayForContainersEnum2 =
+  ClosedEnum<
+    typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum2
+  >;
+
+export type ProviderSetupUpdateAzureApplicationGatewayForContainers2 = {
   /**
-   * Download URL for the provider zip
+   * Optional ALB name when using BYO Application Gateway resources.
    */
-  downloadUrl: string;
+  albName?: string | null | undefined;
   /**
-   * Filename of the provider zip
+   * Optional ALB namespace when using BYO Application Gateway resources.
    */
-  filename: string;
+  albNamespace?: string | null | undefined;
   /**
-   * SHA256 checksum of the zip file
+   * Public or internal frontend exposure.
    */
-  shasum: string;
+  frontend: string;
+  provider: SetupUpdateProviderAzureApplicationGatewayForContainersEnum2;
+};
+
+export const SetupUpdateProviderGkeGatewayEnum2 = {
+  GkeGateway: "gkeGateway",
+} as const;
+export type SetupUpdateProviderGkeGatewayEnum2 = ClosedEnum<
+  typeof SetupUpdateProviderGkeGatewayEnum2
+>;
+
+export type ProviderSetupUpdateGkeGateway2 = {
+  provider: SetupUpdateProviderGkeGatewayEnum2;
   /**
-   * URL to the shasums signature file
+   * Optional static address name for the Gateway frontend.
    */
-  shasumsSignatureUrl: string;
+  staticAddressName?: string | null | undefined;
+};
+
+export const SetupUpdateProviderAwsAlbEnum2 = {
+  AwsAlb: "awsAlb",
+} as const;
+export type SetupUpdateProviderAwsAlbEnum2 = ClosedEnum<
+  typeof SetupUpdateProviderAwsAlbEnum2
+>;
+
+export type ProviderSetupUpdateAwsAlb2 = {
   /**
-   * URL to the shasums file
+   * Optional ALB IP address type, such as `dualstack`.
    */
-  shasumsUrl: string;
+  ipAddressType?: string | null | undefined;
+  provider: SetupUpdateProviderAwsAlbEnum2;
   /**
-   * Size of the zip file in bytes
+   * Internet-facing or internal ALB scheme.
    */
-  size: number;
+  scheme: string;
+  /**
+   * Explicit subnet IDs when the profile cannot rely on controller discovery.
+   */
+  subnetIds?: Array<string> | undefined;
+  /**
+   * ALB target type, usually `ip`.
+   */
+  targetType: string;
 };
 
+export type SetupUpdateProviderUnion2 =
+  | ProviderSetupUpdateAwsAlb2
+  | ProviderSetupUpdateAzureApplicationGatewayForContainers2
+  | ProviderSetupUpdateGkeGateway2
+  | any;
+
 /**
- * Terraform provider registry outputs.
+ * Shared Gateway API route profile values.
  */
-export type DeploymentInfoProvider = {
+export type DeploymentInfoRouteGateway1 = {
   /**
-   * GPG public key for Terraform provider signature verification
+   * Annotations applied to route objects.
    */
-  gpgPublicKey: DeploymentInfoGpgPublicKey;
+  annotations?: { [k: string]: string } | undefined;
   /**
-   * Provider packages for each target platform
+   * Route controller identifier, for example a cloud Gateway controller.
    */
-  platforms: { [k: string]: DeploymentInfoPlatforms };
+  controller?: string | null | undefined;
   /**
-   * Terraform provider source (hostname/namespace/type, without scheme)
+   * GatewayClass selected for generated Gateways.
    */
-  source: string;
+  gatewayClassName: string;
+  /**
+   * Labels applied to route objects.
+   */
+  labels?: { [k: string]: string } | undefined;
+  /**
+   * Listener port, usually 443.
+   */
+  listenerPort: number;
+  provider?:
+    | ProviderSetupUpdateAwsAlb2
+    | ProviderSetupUpdateAzureApplicationGatewayForContainers2
+    | ProviderSetupUpdateGkeGateway2
+    | any
+    | null
+    | undefined;
+  routeApi: "gateway";
 };
 
-/**
- * Outputs from a Terraform package build.
- */
-export type TerraformOutputs = {
+export const SetupUpdateProviderAzureApplicationGatewayForContainersEnum1 = {
+  AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers",
+} as const;
+export type SetupUpdateProviderAzureApplicationGatewayForContainersEnum1 =
+  ClosedEnum<
+    typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum1
+  >;
+
+export type ProviderSetupUpdateAzureApplicationGatewayForContainers1 = {
   /**
-   * Module registry artifacts by Terraform target.
+   * Optional ALB name when using BYO Application Gateway resources.
    */
-  modules: { [k: string]: DeploymentInfoModules };
+  albName?: string | null | undefined;
   /**
-   * Terraform provider registry outputs.
+   * Optional ALB namespace when using BYO Application Gateway resources.
    */
-  provider: DeploymentInfoProvider;
+  albNamespace?: string | null | undefined;
+  /**
+   * Public or internal frontend exposure.
+   */
+  frontend: string;
+  provider: SetupUpdateProviderAzureApplicationGatewayForContainersEnum1;
 };
 
-export type DeploymentInfoTerraform = {
+export const SetupUpdateProviderGkeGatewayEnum1 = {
+  GkeGateway: "gkeGateway",
+} as const;
+export type SetupUpdateProviderGkeGatewayEnum1 = ClosedEnum<
+  typeof SetupUpdateProviderGkeGatewayEnum1
+>;
+
+export type ProviderSetupUpdateGkeGateway1 = {
+  provider: SetupUpdateProviderGkeGatewayEnum1;
   /**
-   * Status of a package build
+   * Optional static address name for the Gateway frontend.
    */
-  status: TerraformStatus;
-  version?: string | undefined;
+  staticAddressName?: string | null | undefined;
+};
+
+export const SetupUpdateProviderAwsAlbEnum1 = {
+  AwsAlb: "awsAlb",
+} as const;
+export type SetupUpdateProviderAwsAlbEnum1 = ClosedEnum<
+  typeof SetupUpdateProviderAwsAlbEnum1
+>;
+
+export type ProviderSetupUpdateAwsAlb1 = {
   /**
-   * Outputs from a Terraform package build.
+   * Optional ALB IP address type, such as `dualstack`.
    */
-  outputs?: TerraformOutputs | undefined;
-  error?: any | null | undefined;
+  ipAddressType?: string | null | undefined;
+  provider: SetupUpdateProviderAwsAlbEnum1;
   /**
-   * Terraform provider source (without https://)
+   * Internet-facing or internal ALB scheme.
    */
-  providerSource: string;
+  scheme: string;
   /**
-   * Terraform module sources by target
+   * Explicit subnet IDs when the profile cannot rely on controller discovery.
    */
-  moduleSources: { [k: string]: string };
-  moduleVersion?: string | undefined;
+  subnetIds?: Array<string> | undefined;
   /**
-   * Manager URLs by Terraform target
+   * ALB target type, usually `ip`.
    */
-  managerUrls: { [k: string]: string };
+  targetType: string;
 };
 
-/**
- * Status of a package build
- */
-export const HelmStatus = {
-  Pending: "pending",
-  Building: "building",
-  Ready: "ready",
-  Failed: "failed",
-  Canceled: "canceled",
-} as const;
-/**
- * Status of a package build
- */
-export type HelmStatus = ClosedEnum<typeof HelmStatus>;
+export type SetupUpdateProviderUnion1 =
+  | ProviderSetupUpdateAwsAlb1
+  | ProviderSetupUpdateAzureApplicationGatewayForContainers1
+  | ProviderSetupUpdateGkeGateway1
+  | any;
 
 /**
- * Outputs from a Helm chart package build
+ * Shared Ingress route profile values.
  */
-export type HelmOutputs = {
-  /**
-   * OCI chart reference (e.g., "oci://public.ecr.aws/acme/charts/project-id")
-   */
-  chart: string;
+export type DeploymentInfoRouteIngress1 = {
   /**
-   * Chart version (e.g., "1.2.3")
+   * Annotations applied to route objects.
    */
-  version: string;
-};
-
-export type DeploymentInfoHelm = {
+  annotations?: { [k: string]: string } | undefined;
   /**
-   * Status of a package build
+   * Route controller identifier, for example `eks.amazonaws.com/alb`.
    */
-  status: HelmStatus;
-  version?: string | undefined;
+  controller?: string | null | undefined;
   /**
-   * Outputs from a Helm chart package build
+   * `spec.ingressClassName` for generated Ingresses.
    */
-  outputs?: HelmOutputs | undefined;
-  error?: any | null | undefined;
+  ingressClassName: string;
   /**
-   * OCI chart reference
+   * Labels applied to route objects.
    */
-  chartRef: string;
-  managerFetchExample?: string | undefined;
-  localImportExample?: string | undefined;
+  labels?: { [k: string]: string } | undefined;
+  provider?:
+    | ProviderSetupUpdateAwsAlb1
+    | ProviderSetupUpdateAzureApplicationGatewayForContainers1
+    | ProviderSetupUpdateGkeGateway1
+    | any
+    | null
+    | undefined;
+  routeApi: "ingress";
 };
 
-export type Packages = {
+/**
+ * Kubernetes route API selected for public endpoints.
+ */
+export type DeploymentInfoRouteUnion1 =
+  | DeploymentInfoRouteIngress1
+  | DeploymentInfoRouteGateway1;
+
+export type DeploymentInfoExposureGenerated = {
   /**
-   * True if all enabled packages are ready for deployment
+   * Certificate publication or reference mode for Kubernetes public endpoints.
    */
-  ready: boolean;
-  cli?: DeploymentInfoCli | undefined;
-  cloudformation?: DeploymentInfoCloudformation | undefined;
-  terraform?: DeploymentInfoTerraform | undefined;
-  helm?: DeploymentInfoHelm | undefined;
+  certificate:
+    | DeploymentInfoCertificateTLSSecretRef1
+    | DeploymentInfoCertificateManagedAcmImport1
+    | DeploymentInfoCertificateAwsAcmArn1
+    | DeploymentInfoCertificateManagedTLSSecret1
+    | DeploymentInfoCertificateNone1;
+  mode: SetupUpdateModeGenerated;
+  /**
+   * Kubernetes route API selected for public endpoints.
+   */
+  route: DeploymentInfoRouteIngress1 | DeploymentInfoRouteGateway1;
 };
 
-/**
- * Represents the target cloud platform.
- */
-export const TargetsPlatform = {
-  Aws: "aws",
-  Gcp: "gcp",
-  Azure: "azure",
-  Kubernetes: "kubernetes",
-  Machines: "machines",
-  Local: "local",
-  Test: "test",
+export const SetupUpdateModeDisabled = {
+  Disabled: "disabled",
 } as const;
+export type SetupUpdateModeDisabled = ClosedEnum<
+  typeof SetupUpdateModeDisabled
+>;
+
+export type DeploymentInfoExposureDisabled = {
+  mode: SetupUpdateModeDisabled;
+};
+
+export type DeploymentInfoExposureUnion =
+  | DeploymentInfoExposureCustom
+  | DeploymentInfoExposureGenerated
+  | DeploymentInfoExposureDisabled
+  | any;
+
 /**
- * Represents the target cloud platform.
+ * 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 TargetsPlatform = ClosedEnum<typeof TargetsPlatform>;
+export type DeploymentInfoKubernetes = {
+  cluster?: DeploymentInfoCluster | any | null | undefined;
+  exposure?:
+    | DeploymentInfoExposureCustom
+    | DeploymentInfoExposureGenerated
+    | DeploymentInfoExposureDisabled
+    | any
+    | null
+    | undefined;
+};
 
-export const TargetsPlatformKubernetes = {
-  Kubernetes: "kubernetes",
+export type DeploymentInfoKubernetesUnion = DeploymentInfoKubernetes | any;
+
+export const DeploymentInfoTypeByoVnetAzure = {
+  ByoVnetAzure: "byo-vnet-azure",
 } as const;
-export type TargetsPlatformKubernetes = ClosedEnum<
-  typeof TargetsPlatformKubernetes
+export type DeploymentInfoTypeByoVnetAzure = ClosedEnum<
+  typeof DeploymentInfoTypeByoVnetAzure
 >;
 
-export type DeploymentInfoManagementConfigKubernetes = {
-  platform: TargetsPlatformKubernetes;
+export type DeploymentInfoNetworkByoVnetAzure = {
+  /**
+   * Name of the dedicated classic Application Gateway subnet within the VNet.
+   */
+  applicationGatewaySubnetName?: string | null | undefined;
+  /**
+   * Name of the dedicated subnet that hosts Private Endpoints (e.g. for a
+   *
+   * @remarks
+   * Postgres Flexible Server). A Private Endpoint must not share the private
+   * subnet, which is already claimed by the Container Apps environment's
+   * `infrastructure_subnet_id`. Required only when the stack contains a
+   * Postgres resource; otherwise unused.
+   */
+  privateEndpointSubnetName?: string | null | undefined;
+  /**
+   * Name of the private subnet within the VNet
+   */
+  privateSubnetName: string;
+  /**
+   * Name of the public subnet within the VNet
+   */
+  publicSubnetName: string;
+  type: DeploymentInfoTypeByoVnetAzure;
+  /**
+   * The full resource ID of the existing VNet
+   */
+  vnetResourceId: string;
 };
 
-export const TargetsPlatformAzure = {
-  Azure: "azure",
+export const DeploymentInfoTypeByoVpcGcp = {
+  ByoVpcGcp: "byo-vpc-gcp",
 } as const;
-export type TargetsPlatformAzure = ClosedEnum<typeof TargetsPlatformAzure>;
+export type DeploymentInfoTypeByoVpcGcp = ClosedEnum<
+  typeof DeploymentInfoTypeByoVpcGcp
+>;
 
-/**
- * Azure management configuration extracted from stack settings
- */
-export type DeploymentInfoManagementConfigAzure = {
+export type DeploymentInfoNetworkByoVpcGcp = {
   /**
-   * The managing Azure Tenant ID for cross-tenant access
+   * The name of the existing VPC network
    */
-  managingTenantId: string;
+  networkName: string;
   /**
-   * OIDC issuer URL trusted by the target-side managed identity.
+   * The region of the subnet
    */
-  oidcIssuer: string;
+  region: string;
   /**
-   * OIDC subject claim trusted by the target-side managed identity.
+   * The name of the subnet to use
    */
-  oidcSubject: string;
-  platform: TargetsPlatformAzure;
+  subnetName: string;
+  type: DeploymentInfoTypeByoVpcGcp;
 };
 
-export const TargetsPlatformGcp = {
-  Gcp: "gcp",
+export const DeploymentInfoTypeByoVpcAws = {
+  ByoVpcAws: "byo-vpc-aws",
 } as const;
-export type TargetsPlatformGcp = ClosedEnum<typeof TargetsPlatformGcp>;
+export type DeploymentInfoTypeByoVpcAws = ClosedEnum<
+  typeof DeploymentInfoTypeByoVpcAws
+>;
 
-/**
- * GCP management configuration extracted from stack settings
- */
-export type DeploymentInfoManagementConfigGcp = {
+export type DeploymentInfoNetworkByoVpcAws = {
   /**
-   * Service account email for management roles
+   * IDs of private subnets
    */
-  serviceAccountEmail: string;
-  platform: TargetsPlatformGcp;
+  privateSubnetIds: Array<string>;
+  /**
+   * IDs of public subnets (required for public ingress)
+   */
+  publicSubnetIds: Array<string>;
+  /**
+   * Optional security group IDs to use
+   */
+  securityGroupIds?: Array<string> | undefined;
+  type: DeploymentInfoTypeByoVpcAws;
+  /**
+   * The ID of the existing VPC
+   */
+  vpcId: string;
 };
 
-export const TargetsPlatformAws = {
-  Aws: "aws",
+export const DeploymentInfoTypeCreate = {
+  Create: "create",
 } as const;
-export type TargetsPlatformAws = ClosedEnum<typeof TargetsPlatformAws>;
+export type DeploymentInfoTypeCreate = ClosedEnum<
+  typeof DeploymentInfoTypeCreate
+>;
 
-/**
- * AWS management configuration extracted from stack settings
- */
-export type DeploymentInfoManagementConfigAws = {
+export type DeploymentInfoNetworkCreate = {
   /**
-   * The managing AWS IAM role ARN that can assume cross-account roles
+   * Number of availability zones (default: 2).
    */
-  managingRoleArn: string;
-  platform: TargetsPlatformAws;
+  availabilityZones?: number | undefined;
+  /**
+   * VPC/VNet CIDR block. If not specified, auto-generated from stack ID
+   *
+   * @remarks
+   * to reduce conflicts (e.g., "10.{hash}.0.0/16").
+   */
+  cidr?: string | null | undefined;
+  type: DeploymentInfoTypeCreate;
+};
+
+export const DeploymentInfoTypeUseDefault = {
+  UseDefault: "use-default",
+} as const;
+export type DeploymentInfoTypeUseDefault = ClosedEnum<
+  typeof DeploymentInfoTypeUseDefault
+>;
+
+export type DeploymentInfoNetworkUseDefault = {
+  type: DeploymentInfoTypeUseDefault;
 };
 
+export type DeploymentInfoNetworkUnion =
+  | DeploymentInfoNetworkByoVpcAws
+  | DeploymentInfoNetworkByoVpcGcp
+  | DeploymentInfoNetworkByoVnetAzure
+  | DeploymentInfoNetworkUseDefault
+  | DeploymentInfoNetworkCreate
+  | any;
+
 /**
- * Management configuration for different cloud platforms.
+ * How telemetry (logs, metrics, traces) is handled.
+ */
+export const DeploymentInfoTelemetry = {
+  Off: "off",
+  Auto: "auto",
+  ApprovalRequired: "approval-required",
+} as const;
+/**
+ * How telemetry (logs, metrics, traces) is handled.
+ */
+export type DeploymentInfoTelemetry = ClosedEnum<
+  typeof DeploymentInfoTelemetry
+>;
+
+/**
+ * How updates are delivered to the deployment.
+ */
+export const DeploymentInfoUpdates = {
+  Auto: "auto",
+  ApprovalRequired: "approval-required",
+} as const;
+/**
+ * How updates are delivered to the deployment.
+ */
+export type DeploymentInfoUpdates = ClosedEnum<typeof DeploymentInfoUpdates>;
+
+/**
+ * User-customizable deployment settings specified at deploy time.
  *
  * @remarks
  *
- * Platform-derived configuration for cross-account/cross-tenant access.
- * This is NOT user-specified - it's derived from the Manager's ServiceAccount.
+ * 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 DeploymentInfoManagementConfigUnion =
-  | DeploymentInfoManagementConfigAzure
-  | DeploymentInfoManagementConfigAws
-  | DeploymentInfoManagementConfigGcp
-  | DeploymentInfoManagementConfigKubernetes
-  | any;
-
-export type InstallContextTargets = {
+export type DeploymentInfoStackSettings = {
+  compute?: DeploymentInfoCompute | any | null | undefined;
   /**
-   * Represents the target cloud platform.
+   * Deployment model: how updates are delivered to the remote environment.
    */
-  platform: TargetsPlatform;
-  managerUrl: string;
+  deploymentModel?: DeploymentInfoDeploymentModel | undefined;
+  domains?: DeploymentInfoDomains | any | null | undefined;
   /**
-   * Management configuration for different cloud platforms.
+   * External bindings for pre-existing infrastructure.
    *
    * @remarks
-   *
-   * Platform-derived configuration for cross-account/cross-tenant access.
-   * This is NOT user-specified - it's derived from the Manager's ServiceAccount.
+   * Allows using existing resources (MinIO, Redis, shared Container Apps
+   * Environment, etc.) instead of having Alien provision them.
+   * Required for Kubernetes platform, optional for cloud platforms.
    */
-  managementConfig?:
-    | DeploymentInfoManagementConfigAzure
-    | DeploymentInfoManagementConfigAws
-    | DeploymentInfoManagementConfigGcp
-    | DeploymentInfoManagementConfigKubernetes
+  externalBindings?: DeploymentInfoExternalBindings | null | undefined;
+  /**
+   * How heartbeat health checks are handled.
+   */
+  heartbeats?: DeploymentInfoHeartbeats | undefined;
+  kubernetes?: DeploymentInfoKubernetes | any | null | undefined;
+  network?:
+    | DeploymentInfoNetworkByoVpcAws
+    | DeploymentInfoNetworkByoVpcGcp
+    | DeploymentInfoNetworkByoVnetAzure
+    | DeploymentInfoNetworkUseDefault
+    | DeploymentInfoNetworkCreate
     | any
     | null
     | undefined;
-  awsManagingAccountId?: string | undefined;
+  /**
+   * Exact externally managed endpoint URLs, keyed by resource ID and endpoint name.
+   *
+   * @remarks
+   *
+   * This is intended for adopted Machines deployments whose DNS and certificates remain
+   * customer-owned. The platform passes these URLs to the runtime without creating or
+   * replacing DNS records or certificates.
+   */
+  publicEndpoints?: { [k: string]: { [k: string]: string } } | null | undefined;
+  /**
+   * How telemetry (logs, metrics, traces) is handled.
+   */
+  telemetry?: DeploymentInfoTelemetry | undefined;
+  /**
+   * How updates are delivered to the deployment.
+   */
+  updates?: DeploymentInfoUpdates | undefined;
 };
 
-export type DeploymentInfoInstallContext = {
+export type SetupUpdate = {
+  deploymentId: string;
+  updateOperationId: string;
+  releaseId: string;
+  name: string;
   /**
-   * Deployment-session install context by Terraform/installer target
+   * Represents the target cloud platform.
    */
-  targets: { [k: string]: InstallContextTargets };
+  platform: SetupUpdatePlatform;
+  setupMethod: DeploymentInfoSetupMethod | null;
+  setupMetadata: { [k: string]: any | null } | null;
+  setupTarget: string | null;
+  resourcePrefix: string | null;
+  /**
+   * User-customizable deployment settings specified at deploy time.
+   *
+   * @remarks
+   *
+   * These settings are provided by the customer via CloudFormation parameters,
+   * Terraform attributes, CLI flags, or Helm values. They customize how the
+   * deployment runs and what capabilities are enabled.
+   *
+   * **Key distinction**: StackSettings is user-customizable, while ManagementConfig
+   * is platform-derived (from the Manager's ServiceAccount).
+   */
+  stackSettings: DeploymentInfoStackSettings;
 };
 
-export const ModelAvailabilitySourceStatus = {
-  Current: "current",
-  Stale: "stale",
-  Invalid: "invalid",
+/**
+ * Type of token used to authenticate this request
+ */
+export const DeploymentInfoTokenType = {
+  Deployment: "deployment",
+  DeploymentGroup: "deployment-group",
 } as const;
-export type ModelAvailabilitySourceStatus = ClosedEnum<
-  typeof ModelAvailabilitySourceStatus
+/**
+ * Type of token used to authenticate this request
+ */
+export type DeploymentInfoTokenType = ClosedEnum<
+  typeof DeploymentInfoTokenType
 >;
 
-export type ModelAvailabilitySource = {
-  deploymentId: string;
-  resourceId: string;
-  observedAt: Date;
-  status: ModelAvailabilitySourceStatus;
-  availability?: AiAvailabilityObservation | undefined;
-};
-
-export const ReadinessStatus = {
-  Ready: "ready",
-  NotReady: "notReady",
-  Unknown: "unknown",
+/**
+ * Represents the target cloud platform.
+ */
+export const DeploymentInfoDeploymentPlatform = {
+  Aws: "aws",
+  Gcp: "gcp",
+  Azure: "azure",
+  Kubernetes: "kubernetes",
+  Machines: "machines",
+  Local: "local",
+  Test: "test",
 } as const;
-export type ReadinessStatus = ClosedEnum<typeof ReadinessStatus>;
+/**
+ * Represents the target cloud platform.
+ */
+export type DeploymentInfoDeploymentPlatform = ClosedEnum<
+  typeof DeploymentInfoDeploymentPlatform
+>;
 
-export const CheckStatus = {
-  Passed: "passed",
-  Failed: "failed",
-  Warning: "warning",
-  Unknown: "unknown",
-} as const;
-export type CheckStatus = ClosedEnum<typeof CheckStatus>;
+/**
+ * Deployment details (present when using a deployment-scoped token)
+ */
+export type DeploymentInfoDeployment = {
+  name: string;
+  /**
+   * Represents the target cloud platform.
+   */
+  platform: DeploymentInfoDeploymentPlatform;
+};
 
-export type Check = {
-  code: string;
-  status: CheckStatus;
-  message: string;
-  checkedAt: string;
+/**
+ * Deployment group details (present when using a deployment-group token)
+ */
+export type DeploymentInfoDeploymentGroup = {
+  /**
+   * Unique identifier for the deployment group.
+   */
+  id: string;
+  name: string;
+  pinnedSubdomain: string | null;
 };
 
-export type Readiness = {
-  status: ReadinessStatus;
-  checks: Array<Check>;
+export type DeploymentInfoWorkspace = {
+  id: string;
+  name: string;
+  avatarUrl?: string | null | undefined;
 };
 
-export type DeploymentInfo = {
+export type Portal = {
+  appearance: DeploymentPortalAppearance;
+};
+
+/**
+ * Represents the target cloud platform.
+ */
+export const StackSummaryPlatform = {
+  Aws: "aws",
+  Gcp: "gcp",
+  Azure: "azure",
+  Kubernetes: "kubernetes",
+  Machines: "machines",
+  Local: "local",
+  Test: "test",
+} as const;
+/**
+ * Represents the target cloud platform.
+ */
+export type StackSummaryPlatform = ClosedEnum<typeof StackSummaryPlatform>;
+
+export type ResourceCounts = {
+  workers: number;
+  containers: number;
   /**
-   * Type of token used to authenticate this request
+   * Daemon resources that run on managed runtime machines
    */
-  tokenType: DeploymentInfoTokenType;
+  daemons?: number | undefined;
   /**
-   * Deployment details (present when using a deployment-scoped token)
+   * Resources that declare managed public HTTPS endpoint setup
    */
-  deployment?: DeploymentInfoDeployment | undefined;
+  publicHttpsEndpoints: number;
   /**
-   * Deployment group details (present when using a deployment-group token)
+   * Storage, queue, KV, vault, database, or cache resources that Kubernetes needs Terraform to provision
    */
-  deploymentGroup?: DeploymentInfoDeploymentGroup | undefined;
-  workspace: DeploymentInfoWorkspace;
-  project: DeploymentInfoProject;
-  packages: Packages;
-  installContext: DeploymentInfoInstallContext;
-  supportedRegions: SupportedCloudRegions;
-  modelAvailabilitySources: Array<ModelAvailabilitySource>;
-  setupItems?: Array<SetupItemStatus> | undefined;
-  setupConfig?: DeploymentInfoSetupConfig | undefined;
-  readiness?: Readiness | undefined;
+  externalInfra: number;
+  total: number;
+};
+
+export type PublicEndpoint = {
+  resourceId: string;
+  endpointName: string;
+  hostLabel: string;
+  wildcardSubdomains: boolean;
+};
+
+export type StackSummary = {
+  /**
+   * Platforms supported by the active release
+   */
+  platforms: Array<StackSummaryPlatform>;
+  /**
+   * Whether the stack contains resources that require cloud VPC networking
+   */
+  requiresNetwork: boolean;
+  /**
+   * Whether this release offers one remotely accessible AI resource
+   */
+  customerModels: boolean;
+  resourceCounts: ResourceCounts;
+  /**
+   * Public endpoints declared by the active release stack
+   */
+  publicEndpoints: Array<PublicEndpoint>;
+};
+
+/**
+ * Parent domain for generated deployment URLs. Chosen public subdomains are only allowed when isSystem is false.
+ */
+export type GeneratedDomain = {
+  domain: string;
+  isSystem: boolean;
+};
+
+export type DeploymentInfoProject = {
+  name: string;
+  portal: Portal;
+  stackSummary?: StackSummary | null | undefined;
+  /**
+   * Parent domain for generated deployment URLs. Chosen public subdomains are only allowed when isSystem is false.
+   */
+  generatedDomain?: GeneratedDomain | null | undefined;
+};
+
+/**
+ * Status of a package build
+ */
+export const CliStatus = {
+  Pending: "pending",
+  Building: "building",
+  Ready: "ready",
+  Failed: "failed",
+  Canceled: "canceled",
+} as const;
+/**
+ * Status of a package build
+ */
+export type CliStatus = ClosedEnum<typeof CliStatus>;
+
+/**
+ * Information about a single binary artifact
+ */
+export type DeploymentInfoBinaries = {
+  /**
+   * SHA256 checksum
+   */
+  sha256: string;
+  /**
+   * File size in bytes
+   */
+  size: number;
+  /**
+   * Download URL for the binary
+   */
+  url: string;
+};
+
+/**
+ * Source provenance for a generated CLI package.
+ */
+export type DeploymentInfoBuildInfo = {
+  /**
+   * Alien source commit used to build the source CLI and agent binaries.
+   */
+  alienSha: string;
+  /**
+   * Compute backend source revision used by optional package extensions, if applicable.
+   */
+  horizonSha: string;
+  /**
+   * Machine runtime release manifest embedded into the generated CLI.
+   */
+  machineBundleManifestUrl?: string | null | undefined;
+  /**
+   * Source revision used to build the package service and optional extensions.
+   */
+  platformSha: string;
+  /**
+   * SHA256 checksum of the source runtime helper binary shipped with the CLI package, when present.
+   */
+  sourceAgentBinarySha256?: string | null | undefined;
+  /**
+   * SHA256 checksum of the source deploy CLI binary before white-label config is appended.
+   */
+  sourceCliBinarySha256: string;
+};
+
+/**
+ * Outputs from a CLI package build
+ */
+export type CliOutputs = {
+  /**
+   * Binary information for each target platform
+   */
+  binaries: { [k: string]: DeploymentInfoBinaries };
+  /**
+   * Source provenance for a generated CLI package.
+   */
+  buildInfo: DeploymentInfoBuildInfo;
+};
+
+/**
+ * Install script URLs for each OS
+ */
+export type InstallScripts = {
+  windows: string;
+  mac: string;
+  linux: string;
+};
+
+export type DeploymentInfoCli = {
+  /**
+   * Status of a package build
+   */
+  status: CliStatus;
+  /**
+   * CLI command name to use in install instructions
+   */
+  commandName: string;
+  version?: string | undefined;
+  /**
+   * Outputs from a CLI package build
+   */
+  outputs?: CliOutputs | undefined;
+  error?: any | null | undefined;
+  /**
+   * Install script URLs for each OS
+   */
+  installScripts: InstallScripts;
+};
+
+/**
+ * Status of a package build
+ */
+export const CloudformationStatus = {
+  Pending: "pending",
+  Building: "building",
+  Ready: "ready",
+  Failed: "failed",
+  Canceled: "canceled",
+} as const;
+/**
+ * Status of a package build
+ */
+export type CloudformationStatus = ClosedEnum<typeof CloudformationStatus>;
+
+/**
+ * Information about a single CloudFormation template package for one target.
+ */
+export type CloudformationTargets = {
+  /**
+   * AWS Console quick-launch URL
+   */
+  launchStackUrl: string;
+  /**
+   * SHA256 checksum of the template
+   */
+  sha256: string;
+  /**
+   * Template size in bytes
+   */
+  size: number;
+  /**
+   * S3 URL to the CloudFormation stack policy
+   */
+  stackPolicyUrl: string;
+  /**
+   * CloudFormation target (aws, eks)
+   */
+  target: string;
+  /**
+   * S3 URL to the CloudFormation template
+   */
+  templateUrl: string;
+};
+
+/**
+ * Outputs from a CloudFormation package build.
+ */
+export type CloudformationOutputs = {
+  /**
+   * Template artifacts by CloudFormation target.
+   */
+  targets: { [k: string]: CloudformationTargets };
 };
 
+export const CloudformationMode = {
+  Auto: "auto",
+  Outputs: "outputs",
+} as const;
+export type CloudformationMode = ClosedEnum<typeof CloudformationMode>;
+
+export type DeploymentInfoCloudformation = {
+  /**
+   * Status of a package build
+   */
+  status: CloudformationStatus;
+  version?: string | undefined;
+  /**
+   * Outputs from a CloudFormation package build.
+   */
+  outputs?: CloudformationOutputs | undefined;
+  error?: any | null | undefined;
+  mode: CloudformationMode;
+  /**
+   * CloudFormation launch URL
+   */
+  launchUrl: string;
+  outputsSchema?: any | null | undefined;
+};
+
+/**
+ * Status of a package build
+ */
+export const TerraformStatus = {
+  Pending: "pending",
+  Building: "building",
+  Ready: "ready",
+  Failed: "failed",
+  Canceled: "canceled",
+} as const;
+/**
+ * Status of a package build
+ */
+export type TerraformStatus = ClosedEnum<typeof TerraformStatus>;
+
+/**
+ * Information about a single Terraform module package for one target.
+ */
+export type DeploymentInfoModules = {
+  /**
+   * Download URL for the module archive
+   */
+  downloadUrl: string;
+  /**
+   * Filename of the module archive
+   */
+  filename: string;
+  /**
+   * SHA256 checksum of the archive
+   */
+  shasum: string;
+  /**
+   * Size of the archive in bytes
+   */
+  size: number;
+  /**
+   * Terraform module source (hostname/namespace/name/provider, without scheme)
+   */
+  source: string;
+  /**
+   * Terraform module target (aws, gcp, azure, eks, gke, aks)
+   */
+  target: string;
+  /**
+   * Terraform input variables exposed by this module.
+   */
+  variables?: Array<string> | undefined;
+};
+
+/**
+ * GPG public key for Terraform provider signature verification
+ */
+export type DeploymentInfoGpgPublicKey = {
+  /**
+   * ASCII-armored public key
+   */
+  asciiArmor: string;
+  /**
+   * GPG key ID
+   */
+  keyId: string;
+};
+
+/**
+ * Information about a single Terraform provider package for a specific platform
+ */
+export type DeploymentInfoPlatforms = {
+  /**
+   * Download URL for the provider zip
+   */
+  downloadUrl: string;
+  /**
+   * Filename of the provider zip
+   */
+  filename: string;
+  /**
+   * SHA256 checksum of the zip file
+   */
+  shasum: string;
+  /**
+   * URL to the shasums signature file
+   */
+  shasumsSignatureUrl: string;
+  /**
+   * URL to the shasums file
+   */
+  shasumsUrl: string;
+  /**
+   * Size of the zip file in bytes
+   */
+  size: number;
+};
+
+/**
+ * Terraform provider registry outputs.
+ */
+export type TerraformProvider = {
+  /**
+   * GPG public key for Terraform provider signature verification
+   */
+  gpgPublicKey: DeploymentInfoGpgPublicKey;
+  /**
+   * Provider packages for each target platform
+   */
+  platforms: { [k: string]: DeploymentInfoPlatforms };
+  /**
+   * Terraform provider source (hostname/namespace/type, without scheme)
+   */
+  source: string;
+};
+
+/**
+ * Outputs from a Terraform package build.
+ */
+export type TerraformOutputs = {
+  /**
+   * Module registry artifacts by Terraform target.
+   */
+  modules: { [k: string]: DeploymentInfoModules };
+  /**
+   * Terraform provider registry outputs.
+   */
+  provider: TerraformProvider;
+};
+
+export type DeploymentInfoTerraform = {
+  /**
+   * Status of a package build
+   */
+  status: TerraformStatus;
+  version?: string | undefined;
+  /**
+   * Outputs from a Terraform package build.
+   */
+  outputs?: TerraformOutputs | undefined;
+  error?: any | null | undefined;
+  /**
+   * Terraform provider source (without https://)
+   */
+  providerSource: string;
+  /**
+   * Terraform module sources by target
+   */
+  moduleSources: { [k: string]: string };
+  moduleVersion?: string | undefined;
+  /**
+   * Manager URLs by Terraform target
+   */
+  managerUrls: { [k: string]: string };
+};
+
+/**
+ * Status of a package build
+ */
+export const HelmStatus = {
+  Pending: "pending",
+  Building: "building",
+  Ready: "ready",
+  Failed: "failed",
+  Canceled: "canceled",
+} as const;
+/**
+ * Status of a package build
+ */
+export type HelmStatus = ClosedEnum<typeof HelmStatus>;
+
+/**
+ * Outputs from a Helm chart package build
+ */
+export type HelmOutputs = {
+  /**
+   * OCI chart reference (e.g., "oci://public.ecr.aws/acme/charts/project-id")
+   */
+  chart: string;
+  /**
+   * Chart version (e.g., "1.2.3")
+   */
+  version: string;
+};
+
+export type DeploymentInfoHelm = {
+  /**
+   * Status of a package build
+   */
+  status: HelmStatus;
+  version?: string | undefined;
+  /**
+   * Outputs from a Helm chart package build
+   */
+  outputs?: HelmOutputs | undefined;
+  error?: any | null | undefined;
+  /**
+   * OCI chart reference
+   */
+  chartRef: string;
+  managerFetchExample?: string | undefined;
+  localImportExample?: string | undefined;
+};
+
+export type Packages = {
+  /**
+   * True if all enabled packages are ready for deployment
+   */
+  ready: boolean;
+  cli?: DeploymentInfoCli | undefined;
+  cloudformation?: DeploymentInfoCloudformation | undefined;
+  terraform?: DeploymentInfoTerraform | undefined;
+  helm?: DeploymentInfoHelm | undefined;
+};
+
+/**
+ * Represents the target cloud platform.
+ */
+export const TargetsPlatform = {
+  Aws: "aws",
+  Gcp: "gcp",
+  Azure: "azure",
+  Kubernetes: "kubernetes",
+  Machines: "machines",
+  Local: "local",
+  Test: "test",
+} as const;
+/**
+ * Represents the target cloud platform.
+ */
+export type TargetsPlatform = ClosedEnum<typeof TargetsPlatform>;
+
+export const TargetsPlatformKubernetes = {
+  Kubernetes: "kubernetes",
+} as const;
+export type TargetsPlatformKubernetes = ClosedEnum<
+  typeof TargetsPlatformKubernetes
+>;
+
+export type DeploymentInfoManagementConfigKubernetes = {
+  platform: TargetsPlatformKubernetes;
+};
+
+export const TargetsPlatformAzure = {
+  Azure: "azure",
+} as const;
+export type TargetsPlatformAzure = ClosedEnum<typeof TargetsPlatformAzure>;
+
+/**
+ * Azure management configuration extracted from stack settings
+ */
+export type DeploymentInfoManagementConfigAzure = {
+  /**
+   * The managing Azure Tenant ID for cross-tenant access
+   */
+  managingTenantId: string;
+  /**
+   * OIDC issuer URL trusted by the target-side managed identity.
+   */
+  oidcIssuer: string;
+  /**
+   * OIDC subject claim trusted by the target-side managed identity.
+   */
+  oidcSubject: string;
+  platform: TargetsPlatformAzure;
+};
+
+export const TargetsPlatformGcp = {
+  Gcp: "gcp",
+} as const;
+export type TargetsPlatformGcp = ClosedEnum<typeof TargetsPlatformGcp>;
+
+/**
+ * GCP management configuration extracted from stack settings
+ */
+export type DeploymentInfoManagementConfigGcp = {
+  /**
+   * Service account email for management roles
+   */
+  serviceAccountEmail: string;
+  platform: TargetsPlatformGcp;
+};
+
+export const TargetsPlatformAws = {
+  Aws: "aws",
+} as const;
+export type TargetsPlatformAws = ClosedEnum<typeof TargetsPlatformAws>;
+
+/**
+ * AWS management configuration extracted from stack settings
+ */
+export type DeploymentInfoManagementConfigAws = {
+  /**
+   * The managing AWS IAM role ARN that can assume cross-account roles
+   */
+  managingRoleArn: string;
+  platform: TargetsPlatformAws;
+};
+
+/**
+ * Management configuration for different cloud platforms.
+ *
+ * @remarks
+ *
+ * Platform-derived configuration for cross-account/cross-tenant access.
+ * This is NOT user-specified - it's derived from the Manager's ServiceAccount.
+ */
+export type DeploymentInfoManagementConfigUnion =
+  | DeploymentInfoManagementConfigAzure
+  | DeploymentInfoManagementConfigAws
+  | DeploymentInfoManagementConfigGcp
+  | DeploymentInfoManagementConfigKubernetes
+  | any;
+
+export type InstallContextTargets = {
+  /**
+   * Represents the target cloud platform.
+   */
+  platform: TargetsPlatform;
+  managerUrl: string;
+  /**
+   * Management configuration for different cloud platforms.
+   *
+   * @remarks
+   *
+   * Platform-derived configuration for cross-account/cross-tenant access.
+   * This is NOT user-specified - it's derived from the Manager's ServiceAccount.
+   */
+  managementConfig?:
+    | DeploymentInfoManagementConfigAzure
+    | DeploymentInfoManagementConfigAws
+    | DeploymentInfoManagementConfigGcp
+    | DeploymentInfoManagementConfigKubernetes
+    | any
+    | null
+    | undefined;
+  awsManagingAccountId?: string | undefined;
+};
+
+export type DeploymentInfoInstallContext = {
+  /**
+   * Deployment-session install context by Terraform/installer target
+   */
+  targets: { [k: string]: InstallContextTargets };
+};
+
+export const ModelAvailabilitySourceStatus = {
+  Current: "current",
+  Stale: "stale",
+  Invalid: "invalid",
+} as const;
+export type ModelAvailabilitySourceStatus = ClosedEnum<
+  typeof ModelAvailabilitySourceStatus
+>;
+
+export type ModelAvailabilitySource = {
+  deploymentId: string;
+  resourceId: string;
+  observedAt: Date;
+  status: ModelAvailabilitySourceStatus;
+  availability?: AiAvailabilityObservation | undefined;
+};
+
+export const ReadinessStatus = {
+  Ready: "ready",
+  NotReady: "notReady",
+  Unknown: "unknown",
+} as const;
+export type ReadinessStatus = ClosedEnum<typeof ReadinessStatus>;
+
+export const CheckStatus = {
+  Passed: "passed",
+  Failed: "failed",
+  Warning: "warning",
+  Unknown: "unknown",
+} as const;
+export type CheckStatus = ClosedEnum<typeof CheckStatus>;
+
+export type Check = {
+  code: string;
+  status: CheckStatus;
+  message: string;
+  checkedAt: string;
+};
+
+export type Readiness = {
+  status: ReadinessStatus;
+  checks: Array<Check>;
+};
+
+export type DeploymentInfo = {
+  setupUpdate?: SetupUpdate | undefined;
+  /**
+   * Type of token used to authenticate this request
+   */
+  tokenType: DeploymentInfoTokenType;
+  /**
+   * Deployment details (present when using a deployment-scoped token)
+   */
+  deployment?: DeploymentInfoDeployment | undefined;
+  /**
+   * Deployment group details (present when using a deployment-group token)
+   */
+  deploymentGroup?: DeploymentInfoDeploymentGroup | undefined;
+  workspace: DeploymentInfoWorkspace;
+  project: DeploymentInfoProject;
+  packages: Packages;
+  installContext: DeploymentInfoInstallContext;
+  supportedRegions: SupportedCloudRegions;
+  modelAvailabilitySources: Array<ModelAvailabilitySource>;
+  setupItems?: Array<SetupItemStatus> | undefined;
+  setupConfig?: DeploymentInfoSetupConfig | undefined;
+  readiness?: Readiness | undefined;
+};
+
+/** @internal */
+export const SetupUpdatePlatform$inboundSchema: z.ZodEnum<
+  typeof SetupUpdatePlatform
+> = z.enum(SetupUpdatePlatform);
+
+/** @internal */
+export const DeploymentInfoSetupMethod$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoSetupMethod
+> = z.enum(DeploymentInfoSetupMethod);
+
+/** @internal */
+export const DeploymentInfoFailureDomains2$inboundSchema: z.ZodType<
+  DeploymentInfoFailureDomains2,
+  unknown
+> = z.object({
+  selectedFailureDomains: z.array(z.string()).optional(),
+  spread: z.int(),
+});
+
+export function deploymentInfoFailureDomains2FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoFailureDomains2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoFailureDomains2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoFailureDomains2' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoFailureDomainsUnion2$inboundSchema: z.ZodType<
+  DeploymentInfoFailureDomainsUnion2,
+  unknown
+> = z.union([
+  z.lazy(() => DeploymentInfoFailureDomains2$inboundSchema),
+  z.any(),
+]);
+
+export function deploymentInfoFailureDomainsUnion2FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoFailureDomainsUnion2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoFailureDomainsUnion2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoFailureDomainsUnion2' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoPoolsAutoscale$inboundSchema: z.ZodType<
+  DeploymentInfoPoolsAutoscale,
+  unknown
+> = z.object({
+  failure_domains: z.nullable(
+    z.union([
+      z.lazy(() => DeploymentInfoFailureDomains2$inboundSchema),
+      z.any(),
+    ]),
+  ).optional(),
+  machine: z.nullable(z.string()).optional(),
+  max: z.int(),
+  min: z.int(),
+  mode: z.literal("autoscale"),
+}).transform((v) => {
+  return remap$(v, {
+    "failure_domains": "failureDomains",
+  });
+});
+
+export function deploymentInfoPoolsAutoscaleFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoPoolsAutoscale, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoPoolsAutoscale$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoPoolsAutoscale' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoFailureDomains1$inboundSchema: z.ZodType<
+  DeploymentInfoFailureDomains1,
+  unknown
+> = z.object({
+  selectedFailureDomains: z.array(z.string()).optional(),
+  spread: z.int(),
+});
+
+export function deploymentInfoFailureDomains1FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoFailureDomains1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoFailureDomains1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoFailureDomains1' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoFailureDomainsUnion1$inboundSchema: z.ZodType<
+  DeploymentInfoFailureDomainsUnion1,
+  unknown
+> = z.union([
+  z.lazy(() => DeploymentInfoFailureDomains1$inboundSchema),
+  z.any(),
+]);
+
+export function deploymentInfoFailureDomainsUnion1FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoFailureDomainsUnion1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoFailureDomainsUnion1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoFailureDomainsUnion1' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoPoolsFixed$inboundSchema: z.ZodType<
+  DeploymentInfoPoolsFixed,
+  unknown
+> = z.object({
+  failure_domains: z.nullable(
+    z.union([
+      z.lazy(() => DeploymentInfoFailureDomains1$inboundSchema),
+      z.any(),
+    ]),
+  ).optional(),
+  machine: z.nullable(z.string()).optional(),
+  machines: z.int(),
+  mode: z.literal("fixed"),
+}).transform((v) => {
+  return remap$(v, {
+    "failure_domains": "failureDomains",
+  });
+});
+
+export function deploymentInfoPoolsFixedFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoPoolsFixed, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoPoolsFixed$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoPoolsFixed' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoPoolsUnion$inboundSchema: z.ZodType<
+  DeploymentInfoPoolsUnion,
+  unknown
+> = z.union([
+  z.lazy(() => DeploymentInfoPoolsFixed$inboundSchema),
+  z.lazy(() => DeploymentInfoPoolsAutoscale$inboundSchema),
+]);
+
+export function deploymentInfoPoolsUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoPoolsUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoPoolsUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoPoolsUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCompute$inboundSchema: z.ZodType<
+  DeploymentInfoCompute,
+  unknown
+> = z.object({
+  pools: z.record(
+    z.string(),
+    z.union([
+      z.lazy(() => DeploymentInfoPoolsFixed$inboundSchema),
+      z.lazy(() => DeploymentInfoPoolsAutoscale$inboundSchema),
+    ]),
+  ).optional(),
+});
+
+export function deploymentInfoComputeFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoCompute, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoCompute$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoCompute' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoComputeUnion$inboundSchema: z.ZodType<
+  DeploymentInfoComputeUnion,
+  unknown
+> = z.union([z.lazy(() => DeploymentInfoCompute$inboundSchema), z.any()]);
+
+export function deploymentInfoComputeUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoComputeUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoComputeUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoComputeUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoDeploymentModel$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoDeploymentModel
+> = z.enum(DeploymentInfoDeploymentModel);
+
+/** @internal */
+export const DeploymentInfoAws$inboundSchema: z.ZodType<
+  DeploymentInfoAws,
+  unknown
+> = z.object({
+  certificateArn: z.string(),
+});
+
+export function deploymentInfoAwsFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoAws, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoAws$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoAws' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoAwsUnion$inboundSchema: z.ZodType<
+  DeploymentInfoAwsUnion,
+  unknown
+> = z.union([z.lazy(() => DeploymentInfoAws$inboundSchema), z.any()]);
+
+export function deploymentInfoAwsUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoAwsUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoAwsUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoAwsUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoAzure$inboundSchema: z.ZodType<
+  DeploymentInfoAzure,
+  unknown
+> = z.object({
+  keyVaultCertificateId: z.string(),
+  keyVaultResourceId: z.nullable(z.string()).optional(),
+});
+
+export function deploymentInfoAzureFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoAzure, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoAzure$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoAzure' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoAzureUnion$inboundSchema: z.ZodType<
+  DeploymentInfoAzureUnion,
+  unknown
+> = z.union([z.lazy(() => DeploymentInfoAzure$inboundSchema), z.any()]);
+
+export function deploymentInfoAzureUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoAzureUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoAzureUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoAzureUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoGcp$inboundSchema: z.ZodType<
+  DeploymentInfoGcp,
+  unknown
+> = z.object({
+  certificateName: z.string(),
+});
+
+export function deploymentInfoGcpFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoGcp, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoGcp$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoGcp' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoGcpUnion$inboundSchema: z.ZodType<
+  DeploymentInfoGcpUnion,
+  unknown
+> = z.union([z.lazy(() => DeploymentInfoGcp$inboundSchema), z.any()]);
+
+export function deploymentInfoGcpUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoGcpUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoGcpUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoGcpUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoTlsSecretRef$inboundSchema: z.ZodType<
+  DeploymentInfoTlsSecretRef,
+  unknown
+> = z.object({
+  namespace: z.nullable(z.string()).optional(),
+  secretName: z.string(),
+});
+
+export function deploymentInfoTlsSecretRefFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoTlsSecretRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoTlsSecretRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoTlsSecretRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoDomainsKubernetes$inboundSchema: z.ZodType<
+  DeploymentInfoDomainsKubernetes,
+  unknown
+> = z.object({
+  tlsSecretRef: z.lazy(() => DeploymentInfoTlsSecretRef$inboundSchema),
+});
+
+export function deploymentInfoDomainsKubernetesFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoDomainsKubernetes, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoDomainsKubernetes$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoDomainsKubernetes' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoDomainsKubernetesUnion$inboundSchema: z.ZodType<
+  DeploymentInfoDomainsKubernetesUnion,
+  unknown
+> = z.union([
+  z.lazy(() => DeploymentInfoDomainsKubernetes$inboundSchema),
+  z.any(),
+]);
+
+export function deploymentInfoDomainsKubernetesUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoDomainsKubernetesUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoDomainsKubernetesUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoDomainsKubernetesUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoDomainsCertificate$inboundSchema: z.ZodType<
+  DeploymentInfoDomainsCertificate,
+  unknown
+> = z.object({
+  aws: z.nullable(
+    z.union([z.lazy(() => DeploymentInfoAws$inboundSchema), z.any()]),
+  ).optional(),
+  azure: z.nullable(
+    z.union([z.lazy(() => DeploymentInfoAzure$inboundSchema), z.any()]),
+  ).optional(),
+  gcp: z.nullable(
+    z.union([z.lazy(() => DeploymentInfoGcp$inboundSchema), z.any()]),
+  ).optional(),
+  kubernetes: z.nullable(
+    z.union([
+      z.lazy(() => DeploymentInfoDomainsKubernetes$inboundSchema),
+      z.any(),
+    ]),
+  ).optional(),
+});
+
+export function deploymentInfoDomainsCertificateFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoDomainsCertificate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoDomainsCertificate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoDomainsCertificate' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCustomDomains$inboundSchema: z.ZodType<
+  DeploymentInfoCustomDomains,
+  unknown
+> = z.object({
+  certificate: z.lazy(() => DeploymentInfoDomainsCertificate$inboundSchema),
+  domain: z.string(),
+});
+
+export function deploymentInfoCustomDomainsFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoCustomDomains, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoCustomDomains$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoCustomDomains' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateModeLoadBalancer$inboundSchema: z.ZodEnum<
+  typeof SetupUpdateModeLoadBalancer
+> = z.enum(SetupUpdateModeLoadBalancer);
+
+/** @internal */
+export const DeploymentInfoPublicEndpointTargetLoadBalancer$inboundSchema:
+  z.ZodType<DeploymentInfoPublicEndpointTargetLoadBalancer, unknown> = z.object(
+    {
+      cnameTarget: z.string(),
+      mode: SetupUpdateModeLoadBalancer$inboundSchema,
+    },
+  );
+
+export function deploymentInfoPublicEndpointTargetLoadBalancerFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DeploymentInfoPublicEndpointTargetLoadBalancer,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoPublicEndpointTargetLoadBalancer$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DeploymentInfoPublicEndpointTargetLoadBalancer' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateModeMachineAddresses$inboundSchema: z.ZodEnum<
+  typeof SetupUpdateModeMachineAddresses
+> = z.enum(SetupUpdateModeMachineAddresses);
+
+/** @internal */
+export const DeploymentInfoPublicEndpointTargetMachineAddresses$inboundSchema:
+  z.ZodType<DeploymentInfoPublicEndpointTargetMachineAddresses, unknown> = z
+    .object({
+      mode: SetupUpdateModeMachineAddresses$inboundSchema,
+    });
+
+export function deploymentInfoPublicEndpointTargetMachineAddressesFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DeploymentInfoPublicEndpointTargetMachineAddresses,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoPublicEndpointTargetMachineAddresses$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DeploymentInfoPublicEndpointTargetMachineAddresses' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoPublicEndpointTargetUnion$inboundSchema: z.ZodType<
+  DeploymentInfoPublicEndpointTargetUnion,
+  unknown
+> = z.union([
+  z.lazy(() => DeploymentInfoPublicEndpointTargetLoadBalancer$inboundSchema),
+  z.lazy(() =>
+    DeploymentInfoPublicEndpointTargetMachineAddresses$inboundSchema
+  ),
+  z.any(),
+]);
+
+export function deploymentInfoPublicEndpointTargetUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DeploymentInfoPublicEndpointTargetUnion,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoPublicEndpointTargetUnion$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DeploymentInfoPublicEndpointTargetUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoDomains$inboundSchema: z.ZodType<
+  DeploymentInfoDomains,
+  unknown
+> = z.object({
+  customDomains: z.nullable(
+    z.record(
+      z.string(),
+      z.lazy(() => DeploymentInfoCustomDomains$inboundSchema),
+    ),
+  ).optional(),
+  publicEndpointTarget: z.nullable(
+    z.union([
+      z.lazy(() =>
+        DeploymentInfoPublicEndpointTargetLoadBalancer$inboundSchema
+      ),
+      z.lazy(() =>
+        DeploymentInfoPublicEndpointTargetMachineAddresses$inboundSchema
+      ),
+      z.any(),
+    ]),
+  ).optional(),
+});
+
+export function deploymentInfoDomainsFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoDomains, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoDomains$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoDomains' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoDomainsUnion$inboundSchema: z.ZodType<
+  DeploymentInfoDomainsUnion,
+  unknown
+> = z.union([z.lazy(() => DeploymentInfoDomains$inboundSchema), z.any()]);
+
+export function deploymentInfoDomainsUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoDomainsUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoDomainsUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoDomainsUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoExternalBindings$inboundSchema: z.ZodType<
+  DeploymentInfoExternalBindings,
+  unknown
+> = z.object({});
+
+export function deploymentInfoExternalBindingsFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoExternalBindings, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoExternalBindings$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoExternalBindings' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoHeartbeats$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoHeartbeats
+> = z.enum(DeploymentInfoHeartbeats);
+
+/** @internal */
+export const DeploymentInfoCloud$inboundSchema: z.ZodType<
+  DeploymentInfoCloud,
+  unknown
+> = z.object({
+  accountId: z.nullable(z.string()).optional(),
+  clusterId: z.nullable(z.string()).optional(),
+  clusterName: z.nullable(z.string()).optional(),
+  projectId: z.nullable(z.string()).optional(),
+  region: z.nullable(z.string()).optional(),
+  resourceGroup: z.nullable(z.string()).optional(),
+  subscriptionId: z.nullable(z.string()).optional(),
+});
+
+export function deploymentInfoCloudFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoCloud, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoCloud$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoCloud' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCloudUnion$inboundSchema: z.ZodType<
+  DeploymentInfoCloudUnion,
+  unknown
+> = z.union([z.lazy(() => DeploymentInfoCloud$inboundSchema), z.any()]);
+
+export function deploymentInfoCloudUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoCloudUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoCloudUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoCloudUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoOwnership$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoOwnership
+> = z.enum(DeploymentInfoOwnership);
+
+/** @internal */
+export const DeploymentInfoCluster$inboundSchema: z.ZodType<
+  DeploymentInfoCluster,
+  unknown
+> = z.object({
+  cloud: z.nullable(
+    z.union([z.lazy(() => DeploymentInfoCloud$inboundSchema), z.any()]),
+  ).optional(),
+  namespace: z.nullable(z.string()).optional(),
+  ownership: DeploymentInfoOwnership$inboundSchema,
+});
+
+export function deploymentInfoClusterFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoCluster, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoCluster$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoCluster' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoClusterUnion$inboundSchema: z.ZodType<
+  DeploymentInfoClusterUnion,
+  unknown
+> = z.union([z.lazy(() => DeploymentInfoCluster$inboundSchema), z.any()]);
+
+export function deploymentInfoClusterUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoClusterUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoClusterUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoClusterUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCertificateNone2$inboundSchema: z.ZodType<
+  DeploymentInfoCertificateNone2,
+  unknown
+> = z.object({
+  mode: z.literal("none"),
+});
+
+export function deploymentInfoCertificateNone2FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoCertificateNone2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoCertificateNone2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoCertificateNone2' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCertificateManagedTLSSecret2$inboundSchema:
+  z.ZodType<DeploymentInfoCertificateManagedTLSSecret2, unknown> = z.object({
+    mode: z.literal("managedTlsSecret"),
+    secretNameTemplate: z.string(),
+  });
+
+export function deploymentInfoCertificateManagedTLSSecret2FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DeploymentInfoCertificateManagedTLSSecret2,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoCertificateManagedTLSSecret2$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DeploymentInfoCertificateManagedTLSSecret2' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCertificateAwsAcmArn2$inboundSchema: z.ZodType<
+  DeploymentInfoCertificateAwsAcmArn2,
+  unknown
+> = z.object({
+  certificateArn: z.string(),
+  mode: z.literal("awsAcmArn"),
+});
+
+export function deploymentInfoCertificateAwsAcmArn2FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoCertificateAwsAcmArn2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoCertificateAwsAcmArn2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoCertificateAwsAcmArn2' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCertificateManagedAcmImport2$inboundSchema:
+  z.ZodType<DeploymentInfoCertificateManagedAcmImport2, unknown> = z.object({
+    mode: z.literal("managedAcmImport"),
+    region: z.nullable(z.string()).optional(),
+    tags: z.record(z.string(), z.string()).optional(),
+  });
+
+export function deploymentInfoCertificateManagedAcmImport2FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DeploymentInfoCertificateManagedAcmImport2,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoCertificateManagedAcmImport2$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DeploymentInfoCertificateManagedAcmImport2' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCertificateTLSSecretRef2$inboundSchema: z.ZodType<
+  DeploymentInfoCertificateTLSSecretRef2,
+  unknown
+> = z.object({
+  namespace: z.nullable(z.string()).optional(),
+  secretName: z.string(),
+  mode: z.literal("tlsSecretRef"),
+});
+
+export function deploymentInfoCertificateTLSSecretRef2FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoCertificateTLSSecretRef2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoCertificateTLSSecretRef2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoCertificateTLSSecretRef2' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCertificateUnion2$inboundSchema: z.ZodType<
+  DeploymentInfoCertificateUnion2,
+  unknown
+> = z.union([
+  z.lazy(() => DeploymentInfoCertificateTLSSecretRef2$inboundSchema),
+  z.lazy(() => DeploymentInfoCertificateManagedAcmImport2$inboundSchema),
+  z.lazy(() => DeploymentInfoCertificateAwsAcmArn2$inboundSchema),
+  z.lazy(() => DeploymentInfoCertificateManagedTLSSecret2$inboundSchema),
+  z.lazy(() => DeploymentInfoCertificateNone2$inboundSchema),
+]);
+
+export function deploymentInfoCertificateUnion2FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoCertificateUnion2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoCertificateUnion2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoCertificateUnion2' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateModeCustom$inboundSchema: z.ZodEnum<
+  typeof SetupUpdateModeCustom
+> = z.enum(SetupUpdateModeCustom);
+
+/** @internal */
+export const SetupUpdateProviderAzureApplicationGatewayForContainersEnum4$inboundSchema:
+  z.ZodEnum<
+    typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum4
+  > = z.enum(SetupUpdateProviderAzureApplicationGatewayForContainersEnum4);
+
+/** @internal */
+export const ProviderSetupUpdateAzureApplicationGatewayForContainers4$inboundSchema:
+  z.ZodType<ProviderSetupUpdateAzureApplicationGatewayForContainers4, unknown> =
+    z.object({
+      albName: z.nullable(z.string()).optional(),
+      albNamespace: z.nullable(z.string()).optional(),
+      frontend: z.string(),
+      provider:
+        SetupUpdateProviderAzureApplicationGatewayForContainersEnum4$inboundSchema,
+    });
+
+export function providerSetupUpdateAzureApplicationGatewayForContainers4FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ProviderSetupUpdateAzureApplicationGatewayForContainers4,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ProviderSetupUpdateAzureApplicationGatewayForContainers4$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'ProviderSetupUpdateAzureApplicationGatewayForContainers4' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderGkeGatewayEnum4$inboundSchema: z.ZodEnum<
+  typeof SetupUpdateProviderGkeGatewayEnum4
+> = z.enum(SetupUpdateProviderGkeGatewayEnum4);
+
+/** @internal */
+export const ProviderSetupUpdateGkeGateway4$inboundSchema: z.ZodType<
+  ProviderSetupUpdateGkeGateway4,
+  unknown
+> = z.object({
+  provider: SetupUpdateProviderGkeGatewayEnum4$inboundSchema,
+  staticAddressName: z.nullable(z.string()).optional(),
+});
+
+export function providerSetupUpdateGkeGateway4FromJSON(
+  jsonString: string,
+): SafeParseResult<ProviderSetupUpdateGkeGateway4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProviderSetupUpdateGkeGateway4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProviderSetupUpdateGkeGateway4' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderAwsAlbEnum4$inboundSchema: z.ZodEnum<
+  typeof SetupUpdateProviderAwsAlbEnum4
+> = z.enum(SetupUpdateProviderAwsAlbEnum4);
+
+/** @internal */
+export const ProviderSetupUpdateAwsAlb4$inboundSchema: z.ZodType<
+  ProviderSetupUpdateAwsAlb4,
+  unknown
+> = z.object({
+  ipAddressType: z.nullable(z.string()).optional(),
+  provider: SetupUpdateProviderAwsAlbEnum4$inboundSchema,
+  scheme: z.string(),
+  subnetIds: z.array(z.string()).optional(),
+  targetType: z.string(),
+});
+
+export function providerSetupUpdateAwsAlb4FromJSON(
+  jsonString: string,
+): SafeParseResult<ProviderSetupUpdateAwsAlb4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProviderSetupUpdateAwsAlb4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProviderSetupUpdateAwsAlb4' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderUnion4$inboundSchema: z.ZodType<
+  SetupUpdateProviderUnion4,
+  unknown
+> = z.union([
+  z.lazy(() => ProviderSetupUpdateAwsAlb4$inboundSchema),
+  z.lazy(() =>
+    ProviderSetupUpdateAzureApplicationGatewayForContainers4$inboundSchema
+  ),
+  z.lazy(() => ProviderSetupUpdateGkeGateway4$inboundSchema),
+  z.any(),
+]);
+
+export function setupUpdateProviderUnion4FromJSON(
+  jsonString: string,
+): SafeParseResult<SetupUpdateProviderUnion4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetupUpdateProviderUnion4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetupUpdateProviderUnion4' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoRouteGateway2$inboundSchema: z.ZodType<
+  DeploymentInfoRouteGateway2,
+  unknown
+> = z.object({
+  annotations: z.record(z.string(), z.string()).optional(),
+  controller: z.nullable(z.string()).optional(),
+  gatewayClassName: z.string(),
+  labels: z.record(z.string(), z.string()).optional(),
+  listenerPort: z.int(),
+  provider: z.nullable(
+    z.union([
+      z.lazy(() => ProviderSetupUpdateAwsAlb4$inboundSchema),
+      z.lazy(() =>
+        ProviderSetupUpdateAzureApplicationGatewayForContainers4$inboundSchema
+      ),
+      z.lazy(() => ProviderSetupUpdateGkeGateway4$inboundSchema),
+      z.any(),
+    ]),
+  ).optional(),
+  routeApi: z.literal("gateway"),
+});
+
+export function deploymentInfoRouteGateway2FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoRouteGateway2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoRouteGateway2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoRouteGateway2' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderAzureApplicationGatewayForContainersEnum3$inboundSchema:
+  z.ZodEnum<
+    typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum3
+  > = z.enum(SetupUpdateProviderAzureApplicationGatewayForContainersEnum3);
+
+/** @internal */
+export const ProviderSetupUpdateAzureApplicationGatewayForContainers3$inboundSchema:
+  z.ZodType<ProviderSetupUpdateAzureApplicationGatewayForContainers3, unknown> =
+    z.object({
+      albName: z.nullable(z.string()).optional(),
+      albNamespace: z.nullable(z.string()).optional(),
+      frontend: z.string(),
+      provider:
+        SetupUpdateProviderAzureApplicationGatewayForContainersEnum3$inboundSchema,
+    });
+
+export function providerSetupUpdateAzureApplicationGatewayForContainers3FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ProviderSetupUpdateAzureApplicationGatewayForContainers3,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ProviderSetupUpdateAzureApplicationGatewayForContainers3$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'ProviderSetupUpdateAzureApplicationGatewayForContainers3' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderGkeGatewayEnum3$inboundSchema: z.ZodEnum<
+  typeof SetupUpdateProviderGkeGatewayEnum3
+> = z.enum(SetupUpdateProviderGkeGatewayEnum3);
+
+/** @internal */
+export const ProviderSetupUpdateGkeGateway3$inboundSchema: z.ZodType<
+  ProviderSetupUpdateGkeGateway3,
+  unknown
+> = z.object({
+  provider: SetupUpdateProviderGkeGatewayEnum3$inboundSchema,
+  staticAddressName: z.nullable(z.string()).optional(),
+});
+
+export function providerSetupUpdateGkeGateway3FromJSON(
+  jsonString: string,
+): SafeParseResult<ProviderSetupUpdateGkeGateway3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProviderSetupUpdateGkeGateway3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProviderSetupUpdateGkeGateway3' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderAwsAlbEnum3$inboundSchema: z.ZodEnum<
+  typeof SetupUpdateProviderAwsAlbEnum3
+> = z.enum(SetupUpdateProviderAwsAlbEnum3);
+
+/** @internal */
+export const ProviderSetupUpdateAwsAlb3$inboundSchema: z.ZodType<
+  ProviderSetupUpdateAwsAlb3,
+  unknown
+> = z.object({
+  ipAddressType: z.nullable(z.string()).optional(),
+  provider: SetupUpdateProviderAwsAlbEnum3$inboundSchema,
+  scheme: z.string(),
+  subnetIds: z.array(z.string()).optional(),
+  targetType: z.string(),
+});
+
+export function providerSetupUpdateAwsAlb3FromJSON(
+  jsonString: string,
+): SafeParseResult<ProviderSetupUpdateAwsAlb3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProviderSetupUpdateAwsAlb3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProviderSetupUpdateAwsAlb3' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderUnion3$inboundSchema: z.ZodType<
+  SetupUpdateProviderUnion3,
+  unknown
+> = z.union([
+  z.lazy(() => ProviderSetupUpdateAwsAlb3$inboundSchema),
+  z.lazy(() =>
+    ProviderSetupUpdateAzureApplicationGatewayForContainers3$inboundSchema
+  ),
+  z.lazy(() => ProviderSetupUpdateGkeGateway3$inboundSchema),
+  z.any(),
+]);
+
+export function setupUpdateProviderUnion3FromJSON(
+  jsonString: string,
+): SafeParseResult<SetupUpdateProviderUnion3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetupUpdateProviderUnion3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetupUpdateProviderUnion3' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoRouteIngress2$inboundSchema: z.ZodType<
+  DeploymentInfoRouteIngress2,
+  unknown
+> = z.object({
+  annotations: z.record(z.string(), z.string()).optional(),
+  controller: z.nullable(z.string()).optional(),
+  ingressClassName: z.string(),
+  labels: z.record(z.string(), z.string()).optional(),
+  provider: z.nullable(
+    z.union([
+      z.lazy(() => ProviderSetupUpdateAwsAlb3$inboundSchema),
+      z.lazy(() =>
+        ProviderSetupUpdateAzureApplicationGatewayForContainers3$inboundSchema
+      ),
+      z.lazy(() => ProviderSetupUpdateGkeGateway3$inboundSchema),
+      z.any(),
+    ]),
+  ).optional(),
+  routeApi: z.literal("ingress"),
+});
+
+export function deploymentInfoRouteIngress2FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoRouteIngress2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoRouteIngress2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoRouteIngress2' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoRouteUnion2$inboundSchema: z.ZodType<
+  DeploymentInfoRouteUnion2,
+  unknown
+> = z.union([
+  z.lazy(() => DeploymentInfoRouteIngress2$inboundSchema),
+  z.lazy(() => DeploymentInfoRouteGateway2$inboundSchema),
+]);
+
+export function deploymentInfoRouteUnion2FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoRouteUnion2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoRouteUnion2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoRouteUnion2' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoExposureCustom$inboundSchema: z.ZodType<
+  DeploymentInfoExposureCustom,
+  unknown
+> = z.object({
+  certificate: z.union([
+    z.lazy(() => DeploymentInfoCertificateTLSSecretRef2$inboundSchema),
+    z.lazy(() => DeploymentInfoCertificateManagedAcmImport2$inboundSchema),
+    z.lazy(() => DeploymentInfoCertificateAwsAcmArn2$inboundSchema),
+    z.lazy(() => DeploymentInfoCertificateManagedTLSSecret2$inboundSchema),
+    z.lazy(() => DeploymentInfoCertificateNone2$inboundSchema),
+  ]),
+  domain: z.string(),
+  mode: SetupUpdateModeCustom$inboundSchema,
+  route: z.union([
+    z.lazy(() => DeploymentInfoRouteIngress2$inboundSchema),
+    z.lazy(() => DeploymentInfoRouteGateway2$inboundSchema),
+  ]),
+});
+
+export function deploymentInfoExposureCustomFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoExposureCustom, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoExposureCustom$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoExposureCustom' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCertificateNone1$inboundSchema: z.ZodType<
+  DeploymentInfoCertificateNone1,
+  unknown
+> = z.object({
+  mode: z.literal("none"),
+});
+
+export function deploymentInfoCertificateNone1FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoCertificateNone1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoCertificateNone1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoCertificateNone1' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCertificateManagedTLSSecret1$inboundSchema:
+  z.ZodType<DeploymentInfoCertificateManagedTLSSecret1, unknown> = z.object({
+    mode: z.literal("managedTlsSecret"),
+    secretNameTemplate: z.string(),
+  });
+
+export function deploymentInfoCertificateManagedTLSSecret1FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DeploymentInfoCertificateManagedTLSSecret1,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoCertificateManagedTLSSecret1$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DeploymentInfoCertificateManagedTLSSecret1' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCertificateAwsAcmArn1$inboundSchema: z.ZodType<
+  DeploymentInfoCertificateAwsAcmArn1,
+  unknown
+> = z.object({
+  certificateArn: z.string(),
+  mode: z.literal("awsAcmArn"),
+});
+
+export function deploymentInfoCertificateAwsAcmArn1FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoCertificateAwsAcmArn1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoCertificateAwsAcmArn1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoCertificateAwsAcmArn1' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCertificateManagedAcmImport1$inboundSchema:
+  z.ZodType<DeploymentInfoCertificateManagedAcmImport1, unknown> = z.object({
+    mode: z.literal("managedAcmImport"),
+    region: z.nullable(z.string()).optional(),
+    tags: z.record(z.string(), z.string()).optional(),
+  });
+
+export function deploymentInfoCertificateManagedAcmImport1FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DeploymentInfoCertificateManagedAcmImport1,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoCertificateManagedAcmImport1$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DeploymentInfoCertificateManagedAcmImport1' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCertificateTLSSecretRef1$inboundSchema: z.ZodType<
+  DeploymentInfoCertificateTLSSecretRef1,
+  unknown
+> = z.object({
+  namespace: z.nullable(z.string()).optional(),
+  secretName: z.string(),
+  mode: z.literal("tlsSecretRef"),
+});
+
+export function deploymentInfoCertificateTLSSecretRef1FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoCertificateTLSSecretRef1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeploymentInfoCertificateTLSSecretRef1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoCertificateTLSSecretRef1' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoCertificateUnion1$inboundSchema: z.ZodType<
+  DeploymentInfoCertificateUnion1,
+  unknown
+> = z.union([
+  z.lazy(() => DeploymentInfoCertificateTLSSecretRef1$inboundSchema),
+  z.lazy(() => DeploymentInfoCertificateManagedAcmImport1$inboundSchema),
+  z.lazy(() => DeploymentInfoCertificateAwsAcmArn1$inboundSchema),
+  z.lazy(() => DeploymentInfoCertificateManagedTLSSecret1$inboundSchema),
+  z.lazy(() => DeploymentInfoCertificateNone1$inboundSchema),
+]);
+
+export function deploymentInfoCertificateUnion1FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoCertificateUnion1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoCertificateUnion1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoCertificateUnion1' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateModeGenerated$inboundSchema: z.ZodEnum<
+  typeof SetupUpdateModeGenerated
+> = z.enum(SetupUpdateModeGenerated);
+
+/** @internal */
+export const SetupUpdateProviderAzureApplicationGatewayForContainersEnum2$inboundSchema:
+  z.ZodEnum<
+    typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum2
+  > = z.enum(SetupUpdateProviderAzureApplicationGatewayForContainersEnum2);
+
+/** @internal */
+export const ProviderSetupUpdateAzureApplicationGatewayForContainers2$inboundSchema:
+  z.ZodType<ProviderSetupUpdateAzureApplicationGatewayForContainers2, unknown> =
+    z.object({
+      albName: z.nullable(z.string()).optional(),
+      albNamespace: z.nullable(z.string()).optional(),
+      frontend: z.string(),
+      provider:
+        SetupUpdateProviderAzureApplicationGatewayForContainersEnum2$inboundSchema,
+    });
+
+export function providerSetupUpdateAzureApplicationGatewayForContainers2FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ProviderSetupUpdateAzureApplicationGatewayForContainers2,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ProviderSetupUpdateAzureApplicationGatewayForContainers2$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'ProviderSetupUpdateAzureApplicationGatewayForContainers2' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderGkeGatewayEnum2$inboundSchema: z.ZodEnum<
+  typeof SetupUpdateProviderGkeGatewayEnum2
+> = z.enum(SetupUpdateProviderGkeGatewayEnum2);
+
+/** @internal */
+export const ProviderSetupUpdateGkeGateway2$inboundSchema: z.ZodType<
+  ProviderSetupUpdateGkeGateway2,
+  unknown
+> = z.object({
+  provider: SetupUpdateProviderGkeGatewayEnum2$inboundSchema,
+  staticAddressName: z.nullable(z.string()).optional(),
+});
+
+export function providerSetupUpdateGkeGateway2FromJSON(
+  jsonString: string,
+): SafeParseResult<ProviderSetupUpdateGkeGateway2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProviderSetupUpdateGkeGateway2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProviderSetupUpdateGkeGateway2' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderAwsAlbEnum2$inboundSchema: z.ZodEnum<
+  typeof SetupUpdateProviderAwsAlbEnum2
+> = z.enum(SetupUpdateProviderAwsAlbEnum2);
+
+/** @internal */
+export const ProviderSetupUpdateAwsAlb2$inboundSchema: z.ZodType<
+  ProviderSetupUpdateAwsAlb2,
+  unknown
+> = z.object({
+  ipAddressType: z.nullable(z.string()).optional(),
+  provider: SetupUpdateProviderAwsAlbEnum2$inboundSchema,
+  scheme: z.string(),
+  subnetIds: z.array(z.string()).optional(),
+  targetType: z.string(),
+});
+
+export function providerSetupUpdateAwsAlb2FromJSON(
+  jsonString: string,
+): SafeParseResult<ProviderSetupUpdateAwsAlb2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProviderSetupUpdateAwsAlb2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProviderSetupUpdateAwsAlb2' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderUnion2$inboundSchema: z.ZodType<
+  SetupUpdateProviderUnion2,
+  unknown
+> = z.union([
+  z.lazy(() => ProviderSetupUpdateAwsAlb2$inboundSchema),
+  z.lazy(() =>
+    ProviderSetupUpdateAzureApplicationGatewayForContainers2$inboundSchema
+  ),
+  z.lazy(() => ProviderSetupUpdateGkeGateway2$inboundSchema),
+  z.any(),
+]);
+
+export function setupUpdateProviderUnion2FromJSON(
+  jsonString: string,
+): SafeParseResult<SetupUpdateProviderUnion2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetupUpdateProviderUnion2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetupUpdateProviderUnion2' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoRouteGateway1$inboundSchema: z.ZodType<
+  DeploymentInfoRouteGateway1,
+  unknown
+> = z.object({
+  annotations: z.record(z.string(), z.string()).optional(),
+  controller: z.nullable(z.string()).optional(),
+  gatewayClassName: z.string(),
+  labels: z.record(z.string(), z.string()).optional(),
+  listenerPort: z.int(),
+  provider: z.nullable(
+    z.union([
+      z.lazy(() => ProviderSetupUpdateAwsAlb2$inboundSchema),
+      z.lazy(() =>
+        ProviderSetupUpdateAzureApplicationGatewayForContainers2$inboundSchema
+      ),
+      z.lazy(() => ProviderSetupUpdateGkeGateway2$inboundSchema),
+      z.any(),
+    ]),
+  ).optional(),
+  routeApi: z.literal("gateway"),
+});
+
+export function deploymentInfoRouteGateway1FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoRouteGateway1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoRouteGateway1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoRouteGateway1' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderAzureApplicationGatewayForContainersEnum1$inboundSchema:
+  z.ZodEnum<
+    typeof SetupUpdateProviderAzureApplicationGatewayForContainersEnum1
+  > = z.enum(SetupUpdateProviderAzureApplicationGatewayForContainersEnum1);
+
+/** @internal */
+export const ProviderSetupUpdateAzureApplicationGatewayForContainers1$inboundSchema:
+  z.ZodType<ProviderSetupUpdateAzureApplicationGatewayForContainers1, unknown> =
+    z.object({
+      albName: z.nullable(z.string()).optional(),
+      albNamespace: z.nullable(z.string()).optional(),
+      frontend: z.string(),
+      provider:
+        SetupUpdateProviderAzureApplicationGatewayForContainersEnum1$inboundSchema,
+    });
+
+export function providerSetupUpdateAzureApplicationGatewayForContainers1FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ProviderSetupUpdateAzureApplicationGatewayForContainers1,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ProviderSetupUpdateAzureApplicationGatewayForContainers1$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'ProviderSetupUpdateAzureApplicationGatewayForContainers1' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderGkeGatewayEnum1$inboundSchema: z.ZodEnum<
+  typeof SetupUpdateProviderGkeGatewayEnum1
+> = z.enum(SetupUpdateProviderGkeGatewayEnum1);
+
+/** @internal */
+export const ProviderSetupUpdateGkeGateway1$inboundSchema: z.ZodType<
+  ProviderSetupUpdateGkeGateway1,
+  unknown
+> = z.object({
+  provider: SetupUpdateProviderGkeGatewayEnum1$inboundSchema,
+  staticAddressName: z.nullable(z.string()).optional(),
+});
+
+export function providerSetupUpdateGkeGateway1FromJSON(
+  jsonString: string,
+): SafeParseResult<ProviderSetupUpdateGkeGateway1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProviderSetupUpdateGkeGateway1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProviderSetupUpdateGkeGateway1' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderAwsAlbEnum1$inboundSchema: z.ZodEnum<
+  typeof SetupUpdateProviderAwsAlbEnum1
+> = z.enum(SetupUpdateProviderAwsAlbEnum1);
+
+/** @internal */
+export const ProviderSetupUpdateAwsAlb1$inboundSchema: z.ZodType<
+  ProviderSetupUpdateAwsAlb1,
+  unknown
+> = z.object({
+  ipAddressType: z.nullable(z.string()).optional(),
+  provider: SetupUpdateProviderAwsAlbEnum1$inboundSchema,
+  scheme: z.string(),
+  subnetIds: z.array(z.string()).optional(),
+  targetType: z.string(),
+});
+
+export function providerSetupUpdateAwsAlb1FromJSON(
+  jsonString: string,
+): SafeParseResult<ProviderSetupUpdateAwsAlb1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProviderSetupUpdateAwsAlb1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProviderSetupUpdateAwsAlb1' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateProviderUnion1$inboundSchema: z.ZodType<
+  SetupUpdateProviderUnion1,
+  unknown
+> = z.union([
+  z.lazy(() => ProviderSetupUpdateAwsAlb1$inboundSchema),
+  z.lazy(() =>
+    ProviderSetupUpdateAzureApplicationGatewayForContainers1$inboundSchema
+  ),
+  z.lazy(() => ProviderSetupUpdateGkeGateway1$inboundSchema),
+  z.any(),
+]);
+
+export function setupUpdateProviderUnion1FromJSON(
+  jsonString: string,
+): SafeParseResult<SetupUpdateProviderUnion1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetupUpdateProviderUnion1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetupUpdateProviderUnion1' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoRouteIngress1$inboundSchema: z.ZodType<
+  DeploymentInfoRouteIngress1,
+  unknown
+> = z.object({
+  annotations: z.record(z.string(), z.string()).optional(),
+  controller: z.nullable(z.string()).optional(),
+  ingressClassName: z.string(),
+  labels: z.record(z.string(), z.string()).optional(),
+  provider: z.nullable(
+    z.union([
+      z.lazy(() => ProviderSetupUpdateAwsAlb1$inboundSchema),
+      z.lazy(() =>
+        ProviderSetupUpdateAzureApplicationGatewayForContainers1$inboundSchema
+      ),
+      z.lazy(() => ProviderSetupUpdateGkeGateway1$inboundSchema),
+      z.any(),
+    ]),
+  ).optional(),
+  routeApi: z.literal("ingress"),
+});
+
+export function deploymentInfoRouteIngress1FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoRouteIngress1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoRouteIngress1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoRouteIngress1' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoRouteUnion1$inboundSchema: z.ZodType<
+  DeploymentInfoRouteUnion1,
+  unknown
+> = z.union([
+  z.lazy(() => DeploymentInfoRouteIngress1$inboundSchema),
+  z.lazy(() => DeploymentInfoRouteGateway1$inboundSchema),
+]);
+
+export function deploymentInfoRouteUnion1FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoRouteUnion1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoRouteUnion1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoRouteUnion1' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoExposureGenerated$inboundSchema: z.ZodType<
+  DeploymentInfoExposureGenerated,
+  unknown
+> = z.object({
+  certificate: z.union([
+    z.lazy(() => DeploymentInfoCertificateTLSSecretRef1$inboundSchema),
+    z.lazy(() => DeploymentInfoCertificateManagedAcmImport1$inboundSchema),
+    z.lazy(() => DeploymentInfoCertificateAwsAcmArn1$inboundSchema),
+    z.lazy(() => DeploymentInfoCertificateManagedTLSSecret1$inboundSchema),
+    z.lazy(() => DeploymentInfoCertificateNone1$inboundSchema),
+  ]),
+  mode: SetupUpdateModeGenerated$inboundSchema,
+  route: z.union([
+    z.lazy(() => DeploymentInfoRouteIngress1$inboundSchema),
+    z.lazy(() => DeploymentInfoRouteGateway1$inboundSchema),
+  ]),
+});
+
+export function deploymentInfoExposureGeneratedFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoExposureGenerated, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoExposureGenerated$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoExposureGenerated' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdateModeDisabled$inboundSchema: z.ZodEnum<
+  typeof SetupUpdateModeDisabled
+> = z.enum(SetupUpdateModeDisabled);
+
+/** @internal */
+export const DeploymentInfoExposureDisabled$inboundSchema: z.ZodType<
+  DeploymentInfoExposureDisabled,
+  unknown
+> = z.object({
+  mode: SetupUpdateModeDisabled$inboundSchema,
+});
+
+export function deploymentInfoExposureDisabledFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoExposureDisabled, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoExposureDisabled$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoExposureDisabled' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoExposureUnion$inboundSchema: z.ZodType<
+  DeploymentInfoExposureUnion,
+  unknown
+> = z.union([
+  z.lazy(() => DeploymentInfoExposureCustom$inboundSchema),
+  z.lazy(() => DeploymentInfoExposureGenerated$inboundSchema),
+  z.lazy(() => DeploymentInfoExposureDisabled$inboundSchema),
+  z.any(),
+]);
+
+export function deploymentInfoExposureUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoExposureUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoExposureUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoExposureUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoKubernetes$inboundSchema: z.ZodType<
+  DeploymentInfoKubernetes,
+  unknown
+> = z.object({
+  cluster: z.nullable(
+    z.union([z.lazy(() => DeploymentInfoCluster$inboundSchema), z.any()]),
+  ).optional(),
+  exposure: z.nullable(
+    z.union([
+      z.lazy(() => DeploymentInfoExposureCustom$inboundSchema),
+      z.lazy(() => DeploymentInfoExposureGenerated$inboundSchema),
+      z.lazy(() => DeploymentInfoExposureDisabled$inboundSchema),
+      z.any(),
+    ]),
+  ).optional(),
+});
+
+export function deploymentInfoKubernetesFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoKubernetes, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoKubernetes$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoKubernetes' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoKubernetesUnion$inboundSchema: z.ZodType<
+  DeploymentInfoKubernetesUnion,
+  unknown
+> = z.union([z.lazy(() => DeploymentInfoKubernetes$inboundSchema), z.any()]);
+
+export function deploymentInfoKubernetesUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoKubernetesUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoKubernetesUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoKubernetesUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoTypeByoVnetAzure$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoTypeByoVnetAzure
+> = z.enum(DeploymentInfoTypeByoVnetAzure);
+
+/** @internal */
+export const DeploymentInfoNetworkByoVnetAzure$inboundSchema: z.ZodType<
+  DeploymentInfoNetworkByoVnetAzure,
+  unknown
+> = z.object({
+  application_gateway_subnet_name: z.nullable(z.string()).optional(),
+  private_endpoint_subnet_name: z.nullable(z.string()).optional(),
+  private_subnet_name: z.string(),
+  public_subnet_name: z.string(),
+  type: DeploymentInfoTypeByoVnetAzure$inboundSchema,
+  vnet_resource_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "application_gateway_subnet_name": "applicationGatewaySubnetName",
+    "private_endpoint_subnet_name": "privateEndpointSubnetName",
+    "private_subnet_name": "privateSubnetName",
+    "public_subnet_name": "publicSubnetName",
+    "vnet_resource_id": "vnetResourceId",
+  });
+});
+
+export function deploymentInfoNetworkByoVnetAzureFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoNetworkByoVnetAzure, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoNetworkByoVnetAzure$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoNetworkByoVnetAzure' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoTypeByoVpcGcp$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoTypeByoVpcGcp
+> = z.enum(DeploymentInfoTypeByoVpcGcp);
+
+/** @internal */
+export const DeploymentInfoNetworkByoVpcGcp$inboundSchema: z.ZodType<
+  DeploymentInfoNetworkByoVpcGcp,
+  unknown
+> = z.object({
+  network_name: z.string(),
+  region: z.string(),
+  subnet_name: z.string(),
+  type: DeploymentInfoTypeByoVpcGcp$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "network_name": "networkName",
+    "subnet_name": "subnetName",
+  });
+});
+
+export function deploymentInfoNetworkByoVpcGcpFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoNetworkByoVpcGcp, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoNetworkByoVpcGcp$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoNetworkByoVpcGcp' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoTypeByoVpcAws$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoTypeByoVpcAws
+> = z.enum(DeploymentInfoTypeByoVpcAws);
+
+/** @internal */
+export const DeploymentInfoNetworkByoVpcAws$inboundSchema: z.ZodType<
+  DeploymentInfoNetworkByoVpcAws,
+  unknown
+> = z.object({
+  private_subnet_ids: z.array(z.string()),
+  public_subnet_ids: z.array(z.string()),
+  security_group_ids: z.array(z.string()).optional(),
+  type: DeploymentInfoTypeByoVpcAws$inboundSchema,
+  vpc_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "private_subnet_ids": "privateSubnetIds",
+    "public_subnet_ids": "publicSubnetIds",
+    "security_group_ids": "securityGroupIds",
+    "vpc_id": "vpcId",
+  });
+});
+
+export function deploymentInfoNetworkByoVpcAwsFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoNetworkByoVpcAws, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoNetworkByoVpcAws$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoNetworkByoVpcAws' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoTypeCreate$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoTypeCreate
+> = z.enum(DeploymentInfoTypeCreate);
+
+/** @internal */
+export const DeploymentInfoNetworkCreate$inboundSchema: z.ZodType<
+  DeploymentInfoNetworkCreate,
+  unknown
+> = z.object({
+  availability_zones: z.int().optional(),
+  cidr: z.nullable(z.string()).optional(),
+  type: DeploymentInfoTypeCreate$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "availability_zones": "availabilityZones",
+  });
+});
+
+export function deploymentInfoNetworkCreateFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoNetworkCreate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoNetworkCreate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoNetworkCreate' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoTypeUseDefault$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoTypeUseDefault
+> = z.enum(DeploymentInfoTypeUseDefault);
+
+/** @internal */
+export const DeploymentInfoNetworkUseDefault$inboundSchema: z.ZodType<
+  DeploymentInfoNetworkUseDefault,
+  unknown
+> = z.object({
+  type: DeploymentInfoTypeUseDefault$inboundSchema,
+});
+
+export function deploymentInfoNetworkUseDefaultFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoNetworkUseDefault, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoNetworkUseDefault$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoNetworkUseDefault' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoNetworkUnion$inboundSchema: z.ZodType<
+  DeploymentInfoNetworkUnion,
+  unknown
+> = z.union([
+  z.lazy(() => DeploymentInfoNetworkByoVpcAws$inboundSchema),
+  z.lazy(() => DeploymentInfoNetworkByoVpcGcp$inboundSchema),
+  z.lazy(() => DeploymentInfoNetworkByoVnetAzure$inboundSchema),
+  z.lazy(() => DeploymentInfoNetworkUseDefault$inboundSchema),
+  z.lazy(() => DeploymentInfoNetworkCreate$inboundSchema),
+  z.any(),
+]);
+
+export function deploymentInfoNetworkUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoNetworkUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoNetworkUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoNetworkUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInfoTelemetry$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoTelemetry
+> = z.enum(DeploymentInfoTelemetry);
+
+/** @internal */
+export const DeploymentInfoUpdates$inboundSchema: z.ZodEnum<
+  typeof DeploymentInfoUpdates
+> = z.enum(DeploymentInfoUpdates);
+
+/** @internal */
+export const DeploymentInfoStackSettings$inboundSchema: z.ZodType<
+  DeploymentInfoStackSettings,
+  unknown
+> = z.object({
+  compute: z.nullable(
+    z.union([z.lazy(() => DeploymentInfoCompute$inboundSchema), z.any()]),
+  ).optional(),
+  deploymentModel: DeploymentInfoDeploymentModel$inboundSchema.optional(),
+  domains: z.nullable(
+    z.union([z.lazy(() => DeploymentInfoDomains$inboundSchema), z.any()]),
+  ).optional(),
+  externalBindings: z.nullable(
+    z.lazy(() => DeploymentInfoExternalBindings$inboundSchema),
+  ).optional(),
+  heartbeats: DeploymentInfoHeartbeats$inboundSchema.optional(),
+  kubernetes: z.nullable(
+    z.union([z.lazy(() => DeploymentInfoKubernetes$inboundSchema), z.any()]),
+  ).optional(),
+  network: z.nullable(
+    z.union([
+      z.lazy(() => DeploymentInfoNetworkByoVpcAws$inboundSchema),
+      z.lazy(() => DeploymentInfoNetworkByoVpcGcp$inboundSchema),
+      z.lazy(() => DeploymentInfoNetworkByoVnetAzure$inboundSchema),
+      z.lazy(() => DeploymentInfoNetworkUseDefault$inboundSchema),
+      z.lazy(() => DeploymentInfoNetworkCreate$inboundSchema),
+      z.any(),
+    ]),
+  ).optional(),
+  publicEndpoints: z.nullable(
+    z.record(z.string(), z.record(z.string(), z.string())),
+  ).optional(),
+  telemetry: DeploymentInfoTelemetry$inboundSchema.optional(),
+  updates: DeploymentInfoUpdates$inboundSchema.optional(),
+});
+
+export function deploymentInfoStackSettingsFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInfoStackSettings, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInfoStackSettings$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInfoStackSettings' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetupUpdate$inboundSchema: z.ZodType<SetupUpdate, unknown> = z
+  .object({
+    deploymentId: z.string(),
+    updateOperationId: z.string(),
+    releaseId: z.string(),
+    name: z.string(),
+    platform: SetupUpdatePlatform$inboundSchema,
+    setupMethod: z.nullable(DeploymentInfoSetupMethod$inboundSchema),
+    setupMetadata: z.nullable(z.record(z.string(), z.nullable(z.any()))),
+    setupTarget: z.nullable(z.string()),
+    resourcePrefix: z.nullable(z.string()),
+    stackSettings: z.lazy(() => DeploymentInfoStackSettings$inboundSchema),
+  });
+
+export function setupUpdateFromJSON(
+  jsonString: string,
+): SafeParseResult<SetupUpdate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetupUpdate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetupUpdate' from JSON`,
+  );
+}
+
 /** @internal */
 export const DeploymentInfoTokenType$inboundSchema: z.ZodEnum<
   typeof DeploymentInfoTokenType
@@ -1119,9 +4264,9 @@ export function cloudformationOutputsFromJSON(
 }
 
 /** @internal */
-export const DeploymentInfoMode$inboundSchema: z.ZodEnum<
-  typeof DeploymentInfoMode
-> = z.enum(DeploymentInfoMode);
+export const CloudformationMode$inboundSchema: z.ZodEnum<
+  typeof CloudformationMode
+> = z.enum(CloudformationMode);
 
 /** @internal */
 export const DeploymentInfoCloudformation$inboundSchema: z.ZodType<
@@ -1132,7 +4277,7 @@ export const DeploymentInfoCloudformation$inboundSchema: z.ZodType<
   version: z.string().optional(),
   outputs: z.lazy(() => CloudformationOutputs$inboundSchema).optional(),
   error: z.nullable(z.any()).optional(),
-  mode: DeploymentInfoMode$inboundSchema,
+  mode: CloudformationMode$inboundSchema,
   launchUrl: z.string(),
   outputsSchema: z.nullable(z.any()).optional(),
 });
@@ -1218,8 +4363,8 @@ export function deploymentInfoPlatformsFromJSON(
 }
 
 /** @internal */
-export const DeploymentInfoProvider$inboundSchema: z.ZodType<
-  DeploymentInfoProvider,
+export const TerraformProvider$inboundSchema: z.ZodType<
+  TerraformProvider,
   unknown
 > = z.object({
   gpgPublicKey: z.lazy(() => DeploymentInfoGpgPublicKey$inboundSchema),
@@ -1230,13 +4375,13 @@ export const DeploymentInfoProvider$inboundSchema: z.ZodType<
   source: z.string(),
 });
 
-export function deploymentInfoProviderFromJSON(
+export function terraformProviderFromJSON(
   jsonString: string,
-): SafeParseResult<DeploymentInfoProvider, SDKValidationError> {
+): SafeParseResult<TerraformProvider, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => DeploymentInfoProvider$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'DeploymentInfoProvider' from JSON`,
+    (x) => TerraformProvider$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TerraformProvider' from JSON`,
   );
 }
 
@@ -1249,7 +4394,7 @@ export const TerraformOutputs$inboundSchema: z.ZodType<
     z.string(),
     z.lazy(() => DeploymentInfoModules$inboundSchema),
   ),
-  provider: z.lazy(() => DeploymentInfoProvider$inboundSchema),
+  provider: z.lazy(() => TerraformProvider$inboundSchema),
 });
 
 export function terraformOutputsFromJSON(
@@ -1607,6 +4752,7 @@ export function readinessFromJSON(
 /** @internal */
 export const DeploymentInfo$inboundSchema: z.ZodType<DeploymentInfo, unknown> =
   z.object({
+    setupUpdate: z.lazy(() => SetupUpdate$inboundSchema).optional(),
     tokenType: DeploymentInfoTokenType$inboundSchema,
     deployment: z.lazy(() => DeploymentInfoDeployment$inboundSchema).optional(),
     deploymentGroup: z.lazy(() => DeploymentInfoDeploymentGroup$inboundSchema)