/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 * @generated-id: 4c12f475d0c6
 */

import * as z from "zod/v4";
import { remap as remap$ } from "../../lib/primitives.js";
import { ClosedEnum } from "../../types/enums.js";
import * as models from "../index.js";

export type PlanDeploymentComputeGlobals = {
  /**
   * Workspace name. Platform API keys already select a workspace; other authentication methods can configure it once on the SDK client.
   */
  workspace?: string | undefined;
};

export const PlanDeploymentComputeSetupItem = {
  Deployment: "deployment",
  Models: "models",
  Keys: "keys",
  Bucket: "bucket",
  Registry: "registry",
  Sandbox: "sandbox",
} as const;
export type PlanDeploymentComputeSetupItem = ClosedEnum<
  typeof PlanDeploymentComputeSetupItem
>;

export const PlanDeploymentComputePlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
} as const;
export type PlanDeploymentComputePlatform = ClosedEnum<
  typeof PlanDeploymentComputePlatform
>;

/**
 * Failure-domain policy selected for a compute pool.
 */
export type PlanDeploymentComputeFailureDomains2 = {
  /**
   * Concrete provider domains selected during setup.
   *
   * @remarks
   * Empty delegates deterministic selection to the provider setup implementation.
   */
  selectedFailureDomains?: Array<string> | undefined;
  /**
   * Number of distinct failure domains across which new stateful replicas may be spread.
   */
  spread: number;
};

export type PlanDeploymentComputeFailureDomainsUnion2 =
  | PlanDeploymentComputeFailureDomains2
  | any;

export type PlanDeploymentComputePoolsAutoscale = {
  failureDomains?:
    | PlanDeploymentComputeFailureDomains2
    | any
    | null
    | undefined;
  /**
   * Provider machine type selected for this deployment.
   */
  machine?: string | null | undefined;
  /**
   * Maximum machine count.
   */
  max: number;
  /**
   * Minimum machine count.
   */
  min: number;
  mode: "autoscale";
};

/**
 * Failure-domain policy selected for a compute pool.
 */
export type PlanDeploymentComputeFailureDomains1 = {
  /**
   * Concrete provider domains selected during setup.
   *
   * @remarks
   * Empty delegates deterministic selection to the provider setup implementation.
   */
  selectedFailureDomains?: Array<string> | undefined;
  /**
   * Number of distinct failure domains across which new stateful replicas may be spread.
   */
  spread: number;
};

export type PlanDeploymentComputeFailureDomainsUnion1 =
  | PlanDeploymentComputeFailureDomains1
  | any;

export type PlanDeploymentComputePoolsFixed = {
  failureDomains?:
    | PlanDeploymentComputeFailureDomains1
    | any
    | null
    | undefined;
  /**
   * Provider machine type selected for this deployment.
   */
  machine?: string | null | undefined;
  /**
   * Number of machines to run.
   */
  machines: number;
  mode: "fixed";
};

/**
 * User-selected deployment settings for one compute pool.
 */
export type PlanDeploymentComputePoolsUnion =
  | PlanDeploymentComputePoolsFixed
  | PlanDeploymentComputePoolsAutoscale;

/**
 * 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 PlanDeploymentComputeCompute = {
  /**
   * Selected compute choices keyed by pool ID.
   */
  pools?: {
    [k: string]:
      | PlanDeploymentComputePoolsFixed
      | PlanDeploymentComputePoolsAutoscale;
  } | undefined;
};

export type PlanDeploymentComputeComputeUnion =
  | PlanDeploymentComputeCompute
  | any;

/**
 * Deployment model: how updates are delivered to the remote environment.
 */
export const PlanDeploymentComputeDeploymentModel = {
  Push: "push",
  Pull: "pull",
} as const;
/**
 * Deployment model: how updates are delivered to the remote environment.
 */
export type PlanDeploymentComputeDeploymentModel = ClosedEnum<
  typeof PlanDeploymentComputeDeploymentModel
>;

export type PlanDeploymentComputeAws = {
  certificateArn: string;
};

export type PlanDeploymentComputeAwsUnion = PlanDeploymentComputeAws | any;

export type PlanDeploymentComputeAzure = {
  keyVaultCertificateId: string;
  keyVaultResourceId?: string | null | undefined;
};

export type PlanDeploymentComputeAzureUnion = PlanDeploymentComputeAzure | any;

export type PlanDeploymentComputeGcp = {
  certificateName: string;
};

export type PlanDeploymentComputeGcpUnion = PlanDeploymentComputeGcp | any;

/**
 * Namespace-scoped Kubernetes TLS Secret reference.
 */
export type PlanDeploymentComputeTlsSecretRef = {
  /**
   * Secret namespace. Defaults to the release namespace when omitted.
   */
  namespace?: string | null | undefined;
  /**
   * Secret name.
   */
  secretName: string;
};

export type PlanDeploymentComputeDomainsKubernetes = {
  /**
   * Namespace-scoped Kubernetes TLS Secret reference.
   */
  tlsSecretRef: PlanDeploymentComputeTlsSecretRef;
};

export type PlanDeploymentComputeDomainsKubernetesUnion =
  | PlanDeploymentComputeDomainsKubernetes
  | any;

/**
 * Platform-specific certificate references for custom domains.
 */
export type PlanDeploymentComputeDomainsCertificate = {
  aws?: PlanDeploymentComputeAws | any | null | undefined;
  azure?: PlanDeploymentComputeAzure | any | null | undefined;
  gcp?: PlanDeploymentComputeGcp | any | null | undefined;
  kubernetes?: PlanDeploymentComputeDomainsKubernetes | any | null | undefined;
};

/**
 * Custom domain configuration for a single resource.
 */
export type PlanDeploymentComputeCustomDomains = {
  /**
   * Platform-specific certificate references for custom domains.
   */
  certificate: PlanDeploymentComputeDomainsCertificate;
  /**
   * Fully qualified domain name to use.
   */
  domain: string;
};

export const PlanDeploymentComputeModeLoadBalancer = {
  LoadBalancer: "loadBalancer",
} as const;
export type PlanDeploymentComputeModeLoadBalancer = ClosedEnum<
  typeof PlanDeploymentComputeModeLoadBalancer
>;

export type PlanDeploymentComputePublicEndpointTargetLoadBalancer = {
  /**
   * DNS name or URL for the external load balancer.
   */
  cnameTarget: string;
  mode: PlanDeploymentComputeModeLoadBalancer;
};

export const PlanDeploymentComputeModeMachineAddresses = {
  MachineAddresses: "machineAddresses",
} as const;
export type PlanDeploymentComputeModeMachineAddresses = ClosedEnum<
  typeof PlanDeploymentComputeModeMachineAddresses
>;

export type PlanDeploymentComputePublicEndpointTargetMachineAddresses = {
  mode: PlanDeploymentComputeModeMachineAddresses;
};

export type PlanDeploymentComputePublicEndpointTargetUnion =
  | PlanDeploymentComputePublicEndpointTargetLoadBalancer
  | PlanDeploymentComputePublicEndpointTargetMachineAddresses
  | 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 PlanDeploymentComputeDomains = {
  /**
   * Custom domain configuration per resource ID.
   */
  customDomains?:
    | { [k: string]: PlanDeploymentComputeCustomDomains }
    | null
    | undefined;
  publicEndpointTarget?:
    | PlanDeploymentComputePublicEndpointTargetLoadBalancer
    | PlanDeploymentComputePublicEndpointTargetMachineAddresses
    | any
    | null
    | undefined;
};

export type PlanDeploymentComputeDomainsUnion =
  | PlanDeploymentComputeDomains
  | any;

/**
 * External bindings for pre-existing infrastructure.
 *
 * @remarks
 * Allows using existing resources (MinIO, Redis, shared Container Apps
 * Environment, etc.) instead of having Alien provision them.
 * Required for Kubernetes platform, optional for cloud platforms.
 */
export type PlanDeploymentComputeExternalBindings = {};

/**
 * How heartbeat health checks are handled.
 */
export const PlanDeploymentComputeHeartbeats = {
  Off: "off",
  On: "on",
} as const;
/**
 * How heartbeat health checks are handled.
 */
export type PlanDeploymentComputeHeartbeats = ClosedEnum<
  typeof PlanDeploymentComputeHeartbeats
>;

/**
 * Optional provider-specific identity for a cloud-backed Kubernetes cluster.
 */
export type PlanDeploymentComputeCloud = {
  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 PlanDeploymentComputeCloudUnion = PlanDeploymentComputeCloud | any;

/**
 * Ownership model for the Kubernetes cluster.
 */
export const PlanDeploymentComputeOwnership = {
  Managed: "managed",
  Existing: "existing",
  External: "external",
} as const;
/**
 * Ownership model for the Kubernetes cluster.
 */
export type PlanDeploymentComputeOwnership = ClosedEnum<
  typeof PlanDeploymentComputeOwnership
>;

/**
 * Kubernetes cluster setup settings.
 */
export type PlanDeploymentComputeCluster = {
  cloud?: PlanDeploymentComputeCloud | any | null | undefined;
  /**
   * Namespace where the Alien chart and application resources run.
   */
  namespace?: string | null | undefined;
  /**
   * Ownership model for the Kubernetes cluster.
   */
  ownership: PlanDeploymentComputeOwnership;
};

export type PlanDeploymentComputeClusterUnion =
  | PlanDeploymentComputeCluster
  | any;

export type PlanDeploymentComputeCertificateNone2 = {
  mode: "none";
};

export type PlanDeploymentComputeCertificateManagedTLSSecret2 = {
  mode: "managedTlsSecret";
  /**
   * Secret name template. Runtime may substitute resource/deployment tokens.
   */
  secretNameTemplate: string;
};

export type PlanDeploymentComputeCertificateAwsAcmArn2 = {
  /**
   * Existing ACM certificate ARN.
   */
  certificateArn: string;
  mode: "awsAcmArn";
};

export type PlanDeploymentComputeCertificateManagedAcmImport2 = {
  mode: "managedAcmImport";
  /**
   * ACM region. Defaults to the deployment region when omitted.
   */
  region?: string | null | undefined;
  /**
   * Tags applied to runtime-imported ACM certificates.
   */
  tags?: { [k: string]: string } | undefined;
};

/**
 * Namespace-scoped Kubernetes TLS Secret reference.
 */
export type PlanDeploymentComputeCertificateTLSSecretRef2 = {
  /**
   * Secret namespace. Defaults to the release namespace when omitted.
   */
  namespace?: string | null | undefined;
  /**
   * Secret name.
   */
  secretName: string;
  mode: "tlsSecretRef";
};

/**
 * Certificate publication or reference mode for Kubernetes public endpoints.
 */
export type PlanDeploymentComputeCertificateUnion2 =
  | PlanDeploymentComputeCertificateTLSSecretRef2
  | PlanDeploymentComputeCertificateManagedAcmImport2
  | PlanDeploymentComputeCertificateAwsAcmArn2
  | PlanDeploymentComputeCertificateManagedTLSSecret2
  | PlanDeploymentComputeCertificateNone2;

export const PlanDeploymentComputeModeCustom = {
  Custom: "custom",
} as const;
export type PlanDeploymentComputeModeCustom = ClosedEnum<
  typeof PlanDeploymentComputeModeCustom
>;

export const PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum4 =
  {
    AzureApplicationGatewayForContainers:
      "azureApplicationGatewayForContainers",
  } as const;
export type PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum4 =
  ClosedEnum<
    typeof PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum4
  >;

export type PlanDeploymentComputeProviderAzureApplicationGatewayForContainers4 =
  {
    /**
     * Optional ALB name when using BYO Application Gateway resources.
     */
    albName?: string | null | undefined;
    /**
     * Optional ALB namespace when using BYO Application Gateway resources.
     */
    albNamespace?: string | null | undefined;
    /**
     * Public or internal frontend exposure.
     */
    frontend: string;
    provider:
      PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum4;
  };

export const PlanDeploymentComputeProviderGkeGatewayEnum4 = {
  GkeGateway: "gkeGateway",
} as const;
export type PlanDeploymentComputeProviderGkeGatewayEnum4 = ClosedEnum<
  typeof PlanDeploymentComputeProviderGkeGatewayEnum4
>;

export type PlanDeploymentComputeProviderGkeGateway4 = {
  provider: PlanDeploymentComputeProviderGkeGatewayEnum4;
  /**
   * Optional static address name for the Gateway frontend.
   */
  staticAddressName?: string | null | undefined;
};

export const PlanDeploymentComputeProviderAwsAlbEnum4 = {
  AwsAlb: "awsAlb",
} as const;
export type PlanDeploymentComputeProviderAwsAlbEnum4 = ClosedEnum<
  typeof PlanDeploymentComputeProviderAwsAlbEnum4
>;

export type PlanDeploymentComputeProviderAwsAlb4 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: PlanDeploymentComputeProviderAwsAlbEnum4;
  /**
   * 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 PlanDeploymentComputeProviderUnion4 =
  | PlanDeploymentComputeProviderAwsAlb4
  | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers4
  | PlanDeploymentComputeProviderGkeGateway4
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type PlanDeploymentComputeRouteGateway2 = {
  /**
   * Annotations applied to route objects.
   */
  annotations?: { [k: string]: string } | undefined;
  /**
   * Route controller identifier, for example a cloud Gateway controller.
   */
  controller?: string | null | undefined;
  /**
   * GatewayClass selected for generated Gateways.
   */
  gatewayClassName: string;
  /**
   * Labels applied to route objects.
   */
  labels?: { [k: string]: string } | undefined;
  /**
   * Listener port, usually 443.
   */
  listenerPort: number;
  provider?:
    | PlanDeploymentComputeProviderAwsAlb4
    | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers4
    | PlanDeploymentComputeProviderGkeGateway4
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

export const PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum3 =
  {
    AzureApplicationGatewayForContainers:
      "azureApplicationGatewayForContainers",
  } as const;
export type PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum3 =
  ClosedEnum<
    typeof PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum3
  >;

export type PlanDeploymentComputeProviderAzureApplicationGatewayForContainers3 =
  {
    /**
     * Optional ALB name when using BYO Application Gateway resources.
     */
    albName?: string | null | undefined;
    /**
     * Optional ALB namespace when using BYO Application Gateway resources.
     */
    albNamespace?: string | null | undefined;
    /**
     * Public or internal frontend exposure.
     */
    frontend: string;
    provider:
      PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum3;
  };

export const PlanDeploymentComputeProviderGkeGatewayEnum3 = {
  GkeGateway: "gkeGateway",
} as const;
export type PlanDeploymentComputeProviderGkeGatewayEnum3 = ClosedEnum<
  typeof PlanDeploymentComputeProviderGkeGatewayEnum3
>;

export type PlanDeploymentComputeProviderGkeGateway3 = {
  provider: PlanDeploymentComputeProviderGkeGatewayEnum3;
  /**
   * Optional static address name for the Gateway frontend.
   */
  staticAddressName?: string | null | undefined;
};

export const PlanDeploymentComputeProviderAwsAlbEnum3 = {
  AwsAlb: "awsAlb",
} as const;
export type PlanDeploymentComputeProviderAwsAlbEnum3 = ClosedEnum<
  typeof PlanDeploymentComputeProviderAwsAlbEnum3
>;

export type PlanDeploymentComputeProviderAwsAlb3 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: PlanDeploymentComputeProviderAwsAlbEnum3;
  /**
   * 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 PlanDeploymentComputeProviderUnion3 =
  | PlanDeploymentComputeProviderAwsAlb3
  | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers3
  | PlanDeploymentComputeProviderGkeGateway3
  | any;

/**
 * Shared Ingress route profile values.
 */
export type PlanDeploymentComputeRouteIngress2 = {
  /**
   * 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?:
    | PlanDeploymentComputeProviderAwsAlb3
    | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers3
    | PlanDeploymentComputeProviderGkeGateway3
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type PlanDeploymentComputeRouteUnion2 =
  | PlanDeploymentComputeRouteIngress2
  | PlanDeploymentComputeRouteGateway2;

export type PlanDeploymentComputeExposureCustom = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | PlanDeploymentComputeCertificateTLSSecretRef2
    | PlanDeploymentComputeCertificateManagedAcmImport2
    | PlanDeploymentComputeCertificateAwsAcmArn2
    | PlanDeploymentComputeCertificateManagedTLSSecret2
    | PlanDeploymentComputeCertificateNone2;
  /**
   * Hostname routed by the Kubernetes public endpoint.
   */
  domain: string;
  mode: PlanDeploymentComputeModeCustom;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route:
    | PlanDeploymentComputeRouteIngress2
    | PlanDeploymentComputeRouteGateway2;
};

export type PlanDeploymentComputeCertificateNone1 = {
  mode: "none";
};

export type PlanDeploymentComputeCertificateManagedTLSSecret1 = {
  mode: "managedTlsSecret";
  /**
   * Secret name template. Runtime may substitute resource/deployment tokens.
   */
  secretNameTemplate: string;
};

export type PlanDeploymentComputeCertificateAwsAcmArn1 = {
  /**
   * Existing ACM certificate ARN.
   */
  certificateArn: string;
  mode: "awsAcmArn";
};

export type PlanDeploymentComputeCertificateManagedAcmImport1 = {
  mode: "managedAcmImport";
  /**
   * ACM region. Defaults to the deployment region when omitted.
   */
  region?: string | null | undefined;
  /**
   * Tags applied to runtime-imported ACM certificates.
   */
  tags?: { [k: string]: string } | undefined;
};

/**
 * Namespace-scoped Kubernetes TLS Secret reference.
 */
export type PlanDeploymentComputeCertificateTLSSecretRef1 = {
  /**
   * Secret namespace. Defaults to the release namespace when omitted.
   */
  namespace?: string | null | undefined;
  /**
   * Secret name.
   */
  secretName: string;
  mode: "tlsSecretRef";
};

/**
 * Certificate publication or reference mode for Kubernetes public endpoints.
 */
export type PlanDeploymentComputeCertificateUnion1 =
  | PlanDeploymentComputeCertificateTLSSecretRef1
  | PlanDeploymentComputeCertificateManagedAcmImport1
  | PlanDeploymentComputeCertificateAwsAcmArn1
  | PlanDeploymentComputeCertificateManagedTLSSecret1
  | PlanDeploymentComputeCertificateNone1;

export const PlanDeploymentComputeModeGenerated = {
  Generated: "generated",
} as const;
export type PlanDeploymentComputeModeGenerated = ClosedEnum<
  typeof PlanDeploymentComputeModeGenerated
>;

export const PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum2 =
  {
    AzureApplicationGatewayForContainers:
      "azureApplicationGatewayForContainers",
  } as const;
export type PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum2 =
  ClosedEnum<
    typeof PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum2
  >;

export type PlanDeploymentComputeProviderAzureApplicationGatewayForContainers2 =
  {
    /**
     * Optional ALB name when using BYO Application Gateway resources.
     */
    albName?: string | null | undefined;
    /**
     * Optional ALB namespace when using BYO Application Gateway resources.
     */
    albNamespace?: string | null | undefined;
    /**
     * Public or internal frontend exposure.
     */
    frontend: string;
    provider:
      PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum2;
  };

export const PlanDeploymentComputeProviderGkeGatewayEnum2 = {
  GkeGateway: "gkeGateway",
} as const;
export type PlanDeploymentComputeProviderGkeGatewayEnum2 = ClosedEnum<
  typeof PlanDeploymentComputeProviderGkeGatewayEnum2
>;

export type PlanDeploymentComputeProviderGkeGateway2 = {
  provider: PlanDeploymentComputeProviderGkeGatewayEnum2;
  /**
   * Optional static address name for the Gateway frontend.
   */
  staticAddressName?: string | null | undefined;
};

export const PlanDeploymentComputeProviderAwsAlbEnum2 = {
  AwsAlb: "awsAlb",
} as const;
export type PlanDeploymentComputeProviderAwsAlbEnum2 = ClosedEnum<
  typeof PlanDeploymentComputeProviderAwsAlbEnum2
>;

export type PlanDeploymentComputeProviderAwsAlb2 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: PlanDeploymentComputeProviderAwsAlbEnum2;
  /**
   * 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 PlanDeploymentComputeProviderUnion2 =
  | PlanDeploymentComputeProviderAwsAlb2
  | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers2
  | PlanDeploymentComputeProviderGkeGateway2
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type PlanDeploymentComputeRouteGateway1 = {
  /**
   * Annotations applied to route objects.
   */
  annotations?: { [k: string]: string } | undefined;
  /**
   * Route controller identifier, for example a cloud Gateway controller.
   */
  controller?: string | null | undefined;
  /**
   * GatewayClass selected for generated Gateways.
   */
  gatewayClassName: string;
  /**
   * Labels applied to route objects.
   */
  labels?: { [k: string]: string } | undefined;
  /**
   * Listener port, usually 443.
   */
  listenerPort: number;
  provider?:
    | PlanDeploymentComputeProviderAwsAlb2
    | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers2
    | PlanDeploymentComputeProviderGkeGateway2
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

export const PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum1 =
  {
    AzureApplicationGatewayForContainers:
      "azureApplicationGatewayForContainers",
  } as const;
export type PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum1 =
  ClosedEnum<
    typeof PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum1
  >;

export type PlanDeploymentComputeProviderAzureApplicationGatewayForContainers1 =
  {
    /**
     * Optional ALB name when using BYO Application Gateway resources.
     */
    albName?: string | null | undefined;
    /**
     * Optional ALB namespace when using BYO Application Gateway resources.
     */
    albNamespace?: string | null | undefined;
    /**
     * Public or internal frontend exposure.
     */
    frontend: string;
    provider:
      PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum1;
  };

export const PlanDeploymentComputeProviderGkeGatewayEnum1 = {
  GkeGateway: "gkeGateway",
} as const;
export type PlanDeploymentComputeProviderGkeGatewayEnum1 = ClosedEnum<
  typeof PlanDeploymentComputeProviderGkeGatewayEnum1
>;

export type PlanDeploymentComputeProviderGkeGateway1 = {
  provider: PlanDeploymentComputeProviderGkeGatewayEnum1;
  /**
   * Optional static address name for the Gateway frontend.
   */
  staticAddressName?: string | null | undefined;
};

export const PlanDeploymentComputeProviderAwsAlbEnum1 = {
  AwsAlb: "awsAlb",
} as const;
export type PlanDeploymentComputeProviderAwsAlbEnum1 = ClosedEnum<
  typeof PlanDeploymentComputeProviderAwsAlbEnum1
>;

export type PlanDeploymentComputeProviderAwsAlb1 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: PlanDeploymentComputeProviderAwsAlbEnum1;
  /**
   * 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 PlanDeploymentComputeProviderUnion1 =
  | PlanDeploymentComputeProviderAwsAlb1
  | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers1
  | PlanDeploymentComputeProviderGkeGateway1
  | any;

/**
 * Shared Ingress route profile values.
 */
export type PlanDeploymentComputeRouteIngress1 = {
  /**
   * 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?:
    | PlanDeploymentComputeProviderAwsAlb1
    | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers1
    | PlanDeploymentComputeProviderGkeGateway1
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type PlanDeploymentComputeRouteUnion1 =
  | PlanDeploymentComputeRouteIngress1
  | PlanDeploymentComputeRouteGateway1;

export type PlanDeploymentComputeExposureGenerated = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | PlanDeploymentComputeCertificateTLSSecretRef1
    | PlanDeploymentComputeCertificateManagedAcmImport1
    | PlanDeploymentComputeCertificateAwsAcmArn1
    | PlanDeploymentComputeCertificateManagedTLSSecret1
    | PlanDeploymentComputeCertificateNone1;
  mode: PlanDeploymentComputeModeGenerated;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route:
    | PlanDeploymentComputeRouteIngress1
    | PlanDeploymentComputeRouteGateway1;
};

export const PlanDeploymentComputeModeDisabled = {
  Disabled: "disabled",
} as const;
export type PlanDeploymentComputeModeDisabled = ClosedEnum<
  typeof PlanDeploymentComputeModeDisabled
>;

export type PlanDeploymentComputeExposureDisabled = {
  mode: PlanDeploymentComputeModeDisabled;
};

export type PlanDeploymentComputeExposureUnion =
  | PlanDeploymentComputeExposureCustom
  | PlanDeploymentComputeExposureGenerated
  | PlanDeploymentComputeExposureDisabled
  | any;

/**
 * Kubernetes runtime substrate configuration.
 *
 * @remarks
 *
 * This controls how setup chooses the cluster backing `Platform::Kubernetes`
 * deployments. When omitted, cloud-backed Kubernetes deployments default to a
 * managed cluster and generic/on-prem Kubernetes defaults to an external
 * cluster.
 */
export type PlanDeploymentComputeKubernetes = {
  cluster?: PlanDeploymentComputeCluster | any | null | undefined;
  exposure?:
    | PlanDeploymentComputeExposureCustom
    | PlanDeploymentComputeExposureGenerated
    | PlanDeploymentComputeExposureDisabled
    | any
    | null
    | undefined;
};

export type PlanDeploymentComputeKubernetesUnion =
  | PlanDeploymentComputeKubernetes
  | any;

export const PlanDeploymentComputeTypeByoVnetAzure = {
  ByoVnetAzure: "byo-vnet-azure",
} as const;
export type PlanDeploymentComputeTypeByoVnetAzure = ClosedEnum<
  typeof PlanDeploymentComputeTypeByoVnetAzure
>;

export type PlanDeploymentComputeNetworkByoVnetAzure = {
  /**
   * 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: PlanDeploymentComputeTypeByoVnetAzure;
  /**
   * The full resource ID of the existing VNet
   */
  vnetResourceId: string;
};

export const PlanDeploymentComputeTypeByoVpcGcp = {
  ByoVpcGcp: "byo-vpc-gcp",
} as const;
export type PlanDeploymentComputeTypeByoVpcGcp = ClosedEnum<
  typeof PlanDeploymentComputeTypeByoVpcGcp
>;

export type PlanDeploymentComputeNetworkByoVpcGcp = {
  /**
   * The name of the existing VPC network
   */
  networkName: string;
  /**
   * The region of the subnet
   */
  region: string;
  /**
   * The name of the subnet to use
   */
  subnetName: string;
  type: PlanDeploymentComputeTypeByoVpcGcp;
};

export const PlanDeploymentComputeTypeByoVpcAws = {
  ByoVpcAws: "byo-vpc-aws",
} as const;
export type PlanDeploymentComputeTypeByoVpcAws = ClosedEnum<
  typeof PlanDeploymentComputeTypeByoVpcAws
>;

export type PlanDeploymentComputeNetworkByoVpcAws = {
  /**
   * IDs of private subnets
   */
  privateSubnetIds: Array<string>;
  /**
   * IDs of public subnets (required for public ingress)
   */
  publicSubnetIds: Array<string>;
  /**
   * Optional security group IDs to use
   */
  securityGroupIds?: Array<string> | undefined;
  type: PlanDeploymentComputeTypeByoVpcAws;
  /**
   * The ID of the existing VPC
   */
  vpcId: string;
};

export const PlanDeploymentComputeTypeCreate = {
  Create: "create",
} as const;
export type PlanDeploymentComputeTypeCreate = ClosedEnum<
  typeof PlanDeploymentComputeTypeCreate
>;

export type PlanDeploymentComputeNetworkCreate = {
  /**
   * Number of availability zones (default: 2).
   */
  availabilityZones?: number | undefined;
  /**
   * VPC/VNet CIDR block. If not specified, auto-generated from stack ID
   *
   * @remarks
   * to reduce conflicts (e.g., "10.{hash}.0.0/16").
   */
  cidr?: string | null | undefined;
  type: PlanDeploymentComputeTypeCreate;
};

export const PlanDeploymentComputeTypeUseDefault = {
  UseDefault: "use-default",
} as const;
export type PlanDeploymentComputeTypeUseDefault = ClosedEnum<
  typeof PlanDeploymentComputeTypeUseDefault
>;

export type PlanDeploymentComputeNetworkUseDefault = {
  type: PlanDeploymentComputeTypeUseDefault;
};

export type PlanDeploymentComputeNetworkUnion =
  | PlanDeploymentComputeNetworkByoVpcAws
  | PlanDeploymentComputeNetworkByoVpcGcp
  | PlanDeploymentComputeNetworkByoVnetAzure
  | PlanDeploymentComputeNetworkUseDefault
  | PlanDeploymentComputeNetworkCreate
  | any;

/**
 * How telemetry (logs, metrics, traces) is handled.
 */
export const PlanDeploymentComputeTelemetry = {
  Off: "off",
  Auto: "auto",
  ApprovalRequired: "approval-required",
} as const;
/**
 * How telemetry (logs, metrics, traces) is handled.
 */
export type PlanDeploymentComputeTelemetry = ClosedEnum<
  typeof PlanDeploymentComputeTelemetry
>;

/**
 * How updates are delivered to the deployment.
 */
export const PlanDeploymentComputeUpdates = {
  Auto: "auto",
  ApprovalRequired: "approval-required",
} as const;
/**
 * How updates are delivered to the deployment.
 */
export type PlanDeploymentComputeUpdates = ClosedEnum<
  typeof PlanDeploymentComputeUpdates
>;

/**
 * User-customizable deployment settings specified at deploy time.
 *
 * @remarks
 *
 * These settings are provided by the customer via CloudFormation parameters,
 * Terraform attributes, CLI flags, or Helm values. They customize how the
 * deployment runs and what capabilities are enabled.
 *
 * **Key distinction**: StackSettings is user-customizable, while ManagementConfig
 * is platform-derived (from the Manager's ServiceAccount).
 */
export type PlanDeploymentComputeStackSettings = {
  compute?: PlanDeploymentComputeCompute | any | null | undefined;
  /**
   * Deployment model: how updates are delivered to the remote environment.
   */
  deploymentModel?: PlanDeploymentComputeDeploymentModel | undefined;
  domains?: PlanDeploymentComputeDomains | any | null | undefined;
  /**
   * External bindings for pre-existing infrastructure.
   *
   * @remarks
   * Allows using existing resources (MinIO, Redis, shared Container Apps
   * Environment, etc.) instead of having Alien provision them.
   * Required for Kubernetes platform, optional for cloud platforms.
   */
  externalBindings?: PlanDeploymentComputeExternalBindings | null | undefined;
  /**
   * How heartbeat health checks are handled.
   */
  heartbeats?: PlanDeploymentComputeHeartbeats | undefined;
  kubernetes?: PlanDeploymentComputeKubernetes | any | null | undefined;
  network?:
    | PlanDeploymentComputeNetworkByoVpcAws
    | PlanDeploymentComputeNetworkByoVpcGcp
    | PlanDeploymentComputeNetworkByoVnetAzure
    | PlanDeploymentComputeNetworkUseDefault
    | PlanDeploymentComputeNetworkCreate
    | any
    | null
    | undefined;
  /**
   * Exact externally managed endpoint URLs, keyed by resource ID and endpoint name.
   *
   * @remarks
   *
   * This is intended for adopted Machines deployments whose DNS and certificates remain
   * customer-owned. The platform passes these URLs to the runtime without creating or
   * replacing DNS records or certificates.
   */
  publicEndpoints?: { [k: string]: { [k: string]: string } } | null | undefined;
  /**
   * How telemetry (logs, metrics, traces) is handled.
   */
  telemetry?: PlanDeploymentComputeTelemetry | undefined;
  /**
   * How updates are delivered to the deployment.
   */
  updates?: PlanDeploymentComputeUpdates | undefined;
};

export type PlanDeploymentComputeRequest = {
  setupItem?: PlanDeploymentComputeSetupItem | undefined;
  deploymentId?: string | undefined;
  updateOperationId?: string | undefined;
  platform: PlanDeploymentComputePlatform;
  setupMethod: models.DeploymentSetupMethod;
  region?: string | undefined;
  /**
   * 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: PlanDeploymentComputeStackSettings;
};

/** @internal */
export const PlanDeploymentComputeSetupItem$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeSetupItem
> = z.enum(PlanDeploymentComputeSetupItem);

/** @internal */
export const PlanDeploymentComputePlatform$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputePlatform
> = z.enum(PlanDeploymentComputePlatform);

/** @internal */
export type PlanDeploymentComputeFailureDomains2$Outbound = {
  selectedFailureDomains?: Array<string> | undefined;
  spread: number;
};

/** @internal */
export const PlanDeploymentComputeFailureDomains2$outboundSchema: z.ZodType<
  PlanDeploymentComputeFailureDomains2$Outbound,
  PlanDeploymentComputeFailureDomains2
> = z.object({
  selectedFailureDomains: z.array(z.string()).optional(),
  spread: z.int(),
});

export function planDeploymentComputeFailureDomains2ToJSON(
  planDeploymentComputeFailureDomains2: PlanDeploymentComputeFailureDomains2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeFailureDomains2$outboundSchema.parse(
      planDeploymentComputeFailureDomains2,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeFailureDomainsUnion2$Outbound =
  | PlanDeploymentComputeFailureDomains2$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeFailureDomainsUnion2$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeFailureDomainsUnion2$Outbound,
    PlanDeploymentComputeFailureDomainsUnion2
  > = z.union([
    z.lazy(() => PlanDeploymentComputeFailureDomains2$outboundSchema),
    z.any(),
  ]);

export function planDeploymentComputeFailureDomainsUnion2ToJSON(
  planDeploymentComputeFailureDomainsUnion2:
    PlanDeploymentComputeFailureDomainsUnion2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeFailureDomainsUnion2$outboundSchema.parse(
      planDeploymentComputeFailureDomainsUnion2,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputePoolsAutoscale$Outbound = {
  failure_domains?:
    | PlanDeploymentComputeFailureDomains2$Outbound
    | any
    | null
    | undefined;
  machine?: string | null | undefined;
  max: number;
  min: number;
  mode: "autoscale";
};

/** @internal */
export const PlanDeploymentComputePoolsAutoscale$outboundSchema: z.ZodType<
  PlanDeploymentComputePoolsAutoscale$Outbound,
  PlanDeploymentComputePoolsAutoscale
> = z.object({
  failureDomains: z.nullable(
    z.union([
      z.lazy(() => PlanDeploymentComputeFailureDomains2$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  machine: z.nullable(z.string()).optional(),
  max: z.int(),
  min: z.int(),
  mode: z.literal("autoscale"),
}).transform((v) => {
  return remap$(v, {
    failureDomains: "failure_domains",
  });
});

export function planDeploymentComputePoolsAutoscaleToJSON(
  planDeploymentComputePoolsAutoscale: PlanDeploymentComputePoolsAutoscale,
): string {
  return JSON.stringify(
    PlanDeploymentComputePoolsAutoscale$outboundSchema.parse(
      planDeploymentComputePoolsAutoscale,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeFailureDomains1$Outbound = {
  selectedFailureDomains?: Array<string> | undefined;
  spread: number;
};

/** @internal */
export const PlanDeploymentComputeFailureDomains1$outboundSchema: z.ZodType<
  PlanDeploymentComputeFailureDomains1$Outbound,
  PlanDeploymentComputeFailureDomains1
> = z.object({
  selectedFailureDomains: z.array(z.string()).optional(),
  spread: z.int(),
});

export function planDeploymentComputeFailureDomains1ToJSON(
  planDeploymentComputeFailureDomains1: PlanDeploymentComputeFailureDomains1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeFailureDomains1$outboundSchema.parse(
      planDeploymentComputeFailureDomains1,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeFailureDomainsUnion1$Outbound =
  | PlanDeploymentComputeFailureDomains1$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeFailureDomainsUnion1$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeFailureDomainsUnion1$Outbound,
    PlanDeploymentComputeFailureDomainsUnion1
  > = z.union([
    z.lazy(() => PlanDeploymentComputeFailureDomains1$outboundSchema),
    z.any(),
  ]);

export function planDeploymentComputeFailureDomainsUnion1ToJSON(
  planDeploymentComputeFailureDomainsUnion1:
    PlanDeploymentComputeFailureDomainsUnion1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeFailureDomainsUnion1$outboundSchema.parse(
      planDeploymentComputeFailureDomainsUnion1,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputePoolsFixed$Outbound = {
  failure_domains?:
    | PlanDeploymentComputeFailureDomains1$Outbound
    | any
    | null
    | undefined;
  machine?: string | null | undefined;
  machines: number;
  mode: "fixed";
};

/** @internal */
export const PlanDeploymentComputePoolsFixed$outboundSchema: z.ZodType<
  PlanDeploymentComputePoolsFixed$Outbound,
  PlanDeploymentComputePoolsFixed
> = z.object({
  failureDomains: z.nullable(
    z.union([
      z.lazy(() => PlanDeploymentComputeFailureDomains1$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  machine: z.nullable(z.string()).optional(),
  machines: z.int(),
  mode: z.literal("fixed"),
}).transform((v) => {
  return remap$(v, {
    failureDomains: "failure_domains",
  });
});

export function planDeploymentComputePoolsFixedToJSON(
  planDeploymentComputePoolsFixed: PlanDeploymentComputePoolsFixed,
): string {
  return JSON.stringify(
    PlanDeploymentComputePoolsFixed$outboundSchema.parse(
      planDeploymentComputePoolsFixed,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputePoolsUnion$Outbound =
  | PlanDeploymentComputePoolsFixed$Outbound
  | PlanDeploymentComputePoolsAutoscale$Outbound;

/** @internal */
export const PlanDeploymentComputePoolsUnion$outboundSchema: z.ZodType<
  PlanDeploymentComputePoolsUnion$Outbound,
  PlanDeploymentComputePoolsUnion
> = z.union([
  z.lazy(() => PlanDeploymentComputePoolsFixed$outboundSchema),
  z.lazy(() => PlanDeploymentComputePoolsAutoscale$outboundSchema),
]);

export function planDeploymentComputePoolsUnionToJSON(
  planDeploymentComputePoolsUnion: PlanDeploymentComputePoolsUnion,
): string {
  return JSON.stringify(
    PlanDeploymentComputePoolsUnion$outboundSchema.parse(
      planDeploymentComputePoolsUnion,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCompute$Outbound = {
  pools?: {
    [k: string]:
      | PlanDeploymentComputePoolsFixed$Outbound
      | PlanDeploymentComputePoolsAutoscale$Outbound;
  } | undefined;
};

/** @internal */
export const PlanDeploymentComputeCompute$outboundSchema: z.ZodType<
  PlanDeploymentComputeCompute$Outbound,
  PlanDeploymentComputeCompute
> = z.object({
  pools: z.record(
    z.string(),
    z.union([
      z.lazy(() => PlanDeploymentComputePoolsFixed$outboundSchema),
      z.lazy(() => PlanDeploymentComputePoolsAutoscale$outboundSchema),
    ]),
  ).optional(),
});

export function planDeploymentComputeComputeToJSON(
  planDeploymentComputeCompute: PlanDeploymentComputeCompute,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCompute$outboundSchema.parse(
      planDeploymentComputeCompute,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeComputeUnion$Outbound =
  | PlanDeploymentComputeCompute$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeComputeUnion$outboundSchema: z.ZodType<
  PlanDeploymentComputeComputeUnion$Outbound,
  PlanDeploymentComputeComputeUnion
> = z.union([
  z.lazy(() => PlanDeploymentComputeCompute$outboundSchema),
  z.any(),
]);

export function planDeploymentComputeComputeUnionToJSON(
  planDeploymentComputeComputeUnion: PlanDeploymentComputeComputeUnion,
): string {
  return JSON.stringify(
    PlanDeploymentComputeComputeUnion$outboundSchema.parse(
      planDeploymentComputeComputeUnion,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeDeploymentModel$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeDeploymentModel
> = z.enum(PlanDeploymentComputeDeploymentModel);

/** @internal */
export type PlanDeploymentComputeAws$Outbound = {
  certificateArn: string;
};

/** @internal */
export const PlanDeploymentComputeAws$outboundSchema: z.ZodType<
  PlanDeploymentComputeAws$Outbound,
  PlanDeploymentComputeAws
> = z.object({
  certificateArn: z.string(),
});

export function planDeploymentComputeAwsToJSON(
  planDeploymentComputeAws: PlanDeploymentComputeAws,
): string {
  return JSON.stringify(
    PlanDeploymentComputeAws$outboundSchema.parse(planDeploymentComputeAws),
  );
}

/** @internal */
export type PlanDeploymentComputeAwsUnion$Outbound =
  | PlanDeploymentComputeAws$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeAwsUnion$outboundSchema: z.ZodType<
  PlanDeploymentComputeAwsUnion$Outbound,
  PlanDeploymentComputeAwsUnion
> = z.union([z.lazy(() => PlanDeploymentComputeAws$outboundSchema), z.any()]);

export function planDeploymentComputeAwsUnionToJSON(
  planDeploymentComputeAwsUnion: PlanDeploymentComputeAwsUnion,
): string {
  return JSON.stringify(
    PlanDeploymentComputeAwsUnion$outboundSchema.parse(
      planDeploymentComputeAwsUnion,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeAzure$Outbound = {
  keyVaultCertificateId: string;
  keyVaultResourceId?: string | null | undefined;
};

/** @internal */
export const PlanDeploymentComputeAzure$outboundSchema: z.ZodType<
  PlanDeploymentComputeAzure$Outbound,
  PlanDeploymentComputeAzure
> = z.object({
  keyVaultCertificateId: z.string(),
  keyVaultResourceId: z.nullable(z.string()).optional(),
});

export function planDeploymentComputeAzureToJSON(
  planDeploymentComputeAzure: PlanDeploymentComputeAzure,
): string {
  return JSON.stringify(
    PlanDeploymentComputeAzure$outboundSchema.parse(planDeploymentComputeAzure),
  );
}

/** @internal */
export type PlanDeploymentComputeAzureUnion$Outbound =
  | PlanDeploymentComputeAzure$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeAzureUnion$outboundSchema: z.ZodType<
  PlanDeploymentComputeAzureUnion$Outbound,
  PlanDeploymentComputeAzureUnion
> = z.union([z.lazy(() => PlanDeploymentComputeAzure$outboundSchema), z.any()]);

export function planDeploymentComputeAzureUnionToJSON(
  planDeploymentComputeAzureUnion: PlanDeploymentComputeAzureUnion,
): string {
  return JSON.stringify(
    PlanDeploymentComputeAzureUnion$outboundSchema.parse(
      planDeploymentComputeAzureUnion,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeGcp$Outbound = {
  certificateName: string;
};

/** @internal */
export const PlanDeploymentComputeGcp$outboundSchema: z.ZodType<
  PlanDeploymentComputeGcp$Outbound,
  PlanDeploymentComputeGcp
> = z.object({
  certificateName: z.string(),
});

export function planDeploymentComputeGcpToJSON(
  planDeploymentComputeGcp: PlanDeploymentComputeGcp,
): string {
  return JSON.stringify(
    PlanDeploymentComputeGcp$outboundSchema.parse(planDeploymentComputeGcp),
  );
}

/** @internal */
export type PlanDeploymentComputeGcpUnion$Outbound =
  | PlanDeploymentComputeGcp$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeGcpUnion$outboundSchema: z.ZodType<
  PlanDeploymentComputeGcpUnion$Outbound,
  PlanDeploymentComputeGcpUnion
> = z.union([z.lazy(() => PlanDeploymentComputeGcp$outboundSchema), z.any()]);

export function planDeploymentComputeGcpUnionToJSON(
  planDeploymentComputeGcpUnion: PlanDeploymentComputeGcpUnion,
): string {
  return JSON.stringify(
    PlanDeploymentComputeGcpUnion$outboundSchema.parse(
      planDeploymentComputeGcpUnion,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeTlsSecretRef$Outbound = {
  namespace?: string | null | undefined;
  secretName: string;
};

/** @internal */
export const PlanDeploymentComputeTlsSecretRef$outboundSchema: z.ZodType<
  PlanDeploymentComputeTlsSecretRef$Outbound,
  PlanDeploymentComputeTlsSecretRef
> = z.object({
  namespace: z.nullable(z.string()).optional(),
  secretName: z.string(),
});

export function planDeploymentComputeTlsSecretRefToJSON(
  planDeploymentComputeTlsSecretRef: PlanDeploymentComputeTlsSecretRef,
): string {
  return JSON.stringify(
    PlanDeploymentComputeTlsSecretRef$outboundSchema.parse(
      planDeploymentComputeTlsSecretRef,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeDomainsKubernetes$Outbound = {
  tlsSecretRef: PlanDeploymentComputeTlsSecretRef$Outbound;
};

/** @internal */
export const PlanDeploymentComputeDomainsKubernetes$outboundSchema: z.ZodType<
  PlanDeploymentComputeDomainsKubernetes$Outbound,
  PlanDeploymentComputeDomainsKubernetes
> = z.object({
  tlsSecretRef: z.lazy(() => PlanDeploymentComputeTlsSecretRef$outboundSchema),
});

export function planDeploymentComputeDomainsKubernetesToJSON(
  planDeploymentComputeDomainsKubernetes:
    PlanDeploymentComputeDomainsKubernetes,
): string {
  return JSON.stringify(
    PlanDeploymentComputeDomainsKubernetes$outboundSchema.parse(
      planDeploymentComputeDomainsKubernetes,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeDomainsKubernetesUnion$Outbound =
  | PlanDeploymentComputeDomainsKubernetes$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeDomainsKubernetesUnion$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeDomainsKubernetesUnion$Outbound,
    PlanDeploymentComputeDomainsKubernetesUnion
  > = z.union([
    z.lazy(() => PlanDeploymentComputeDomainsKubernetes$outboundSchema),
    z.any(),
  ]);

export function planDeploymentComputeDomainsKubernetesUnionToJSON(
  planDeploymentComputeDomainsKubernetesUnion:
    PlanDeploymentComputeDomainsKubernetesUnion,
): string {
  return JSON.stringify(
    PlanDeploymentComputeDomainsKubernetesUnion$outboundSchema.parse(
      planDeploymentComputeDomainsKubernetesUnion,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeDomainsCertificate$Outbound = {
  aws?: PlanDeploymentComputeAws$Outbound | any | null | undefined;
  azure?: PlanDeploymentComputeAzure$Outbound | any | null | undefined;
  gcp?: PlanDeploymentComputeGcp$Outbound | any | null | undefined;
  kubernetes?:
    | PlanDeploymentComputeDomainsKubernetes$Outbound
    | any
    | null
    | undefined;
};

/** @internal */
export const PlanDeploymentComputeDomainsCertificate$outboundSchema: z.ZodType<
  PlanDeploymentComputeDomainsCertificate$Outbound,
  PlanDeploymentComputeDomainsCertificate
> = z.object({
  aws: z.nullable(
    z.union([z.lazy(() => PlanDeploymentComputeAws$outboundSchema), z.any()]),
  ).optional(),
  azure: z.nullable(
    z.union([z.lazy(() => PlanDeploymentComputeAzure$outboundSchema), z.any()]),
  ).optional(),
  gcp: z.nullable(
    z.union([z.lazy(() => PlanDeploymentComputeGcp$outboundSchema), z.any()]),
  ).optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => PlanDeploymentComputeDomainsKubernetes$outboundSchema),
      z.any(),
    ]),
  ).optional(),
});

export function planDeploymentComputeDomainsCertificateToJSON(
  planDeploymentComputeDomainsCertificate:
    PlanDeploymentComputeDomainsCertificate,
): string {
  return JSON.stringify(
    PlanDeploymentComputeDomainsCertificate$outboundSchema.parse(
      planDeploymentComputeDomainsCertificate,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCustomDomains$Outbound = {
  certificate: PlanDeploymentComputeDomainsCertificate$Outbound;
  domain: string;
};

/** @internal */
export const PlanDeploymentComputeCustomDomains$outboundSchema: z.ZodType<
  PlanDeploymentComputeCustomDomains$Outbound,
  PlanDeploymentComputeCustomDomains
> = z.object({
  certificate: z.lazy(() =>
    PlanDeploymentComputeDomainsCertificate$outboundSchema
  ),
  domain: z.string(),
});

export function planDeploymentComputeCustomDomainsToJSON(
  planDeploymentComputeCustomDomains: PlanDeploymentComputeCustomDomains,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCustomDomains$outboundSchema.parse(
      planDeploymentComputeCustomDomains,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeModeLoadBalancer$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeModeLoadBalancer
> = z.enum(PlanDeploymentComputeModeLoadBalancer);

/** @internal */
export type PlanDeploymentComputePublicEndpointTargetLoadBalancer$Outbound = {
  cnameTarget: string;
  mode: string;
};

/** @internal */
export const PlanDeploymentComputePublicEndpointTargetLoadBalancer$outboundSchema:
  z.ZodType<
    PlanDeploymentComputePublicEndpointTargetLoadBalancer$Outbound,
    PlanDeploymentComputePublicEndpointTargetLoadBalancer
  > = z.object({
    cnameTarget: z.string(),
    mode: PlanDeploymentComputeModeLoadBalancer$outboundSchema,
  });

export function planDeploymentComputePublicEndpointTargetLoadBalancerToJSON(
  planDeploymentComputePublicEndpointTargetLoadBalancer:
    PlanDeploymentComputePublicEndpointTargetLoadBalancer,
): string {
  return JSON.stringify(
    PlanDeploymentComputePublicEndpointTargetLoadBalancer$outboundSchema.parse(
      planDeploymentComputePublicEndpointTargetLoadBalancer,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeModeMachineAddresses$outboundSchema:
  z.ZodEnum<typeof PlanDeploymentComputeModeMachineAddresses> = z.enum(
    PlanDeploymentComputeModeMachineAddresses,
  );

/** @internal */
export type PlanDeploymentComputePublicEndpointTargetMachineAddresses$Outbound =
  {
    mode: string;
  };

/** @internal */
export const PlanDeploymentComputePublicEndpointTargetMachineAddresses$outboundSchema:
  z.ZodType<
    PlanDeploymentComputePublicEndpointTargetMachineAddresses$Outbound,
    PlanDeploymentComputePublicEndpointTargetMachineAddresses
  > = z.object({
    mode: PlanDeploymentComputeModeMachineAddresses$outboundSchema,
  });

export function planDeploymentComputePublicEndpointTargetMachineAddressesToJSON(
  planDeploymentComputePublicEndpointTargetMachineAddresses:
    PlanDeploymentComputePublicEndpointTargetMachineAddresses,
): string {
  return JSON.stringify(
    PlanDeploymentComputePublicEndpointTargetMachineAddresses$outboundSchema
      .parse(planDeploymentComputePublicEndpointTargetMachineAddresses),
  );
}

/** @internal */
export type PlanDeploymentComputePublicEndpointTargetUnion$Outbound =
  | PlanDeploymentComputePublicEndpointTargetLoadBalancer$Outbound
  | PlanDeploymentComputePublicEndpointTargetMachineAddresses$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputePublicEndpointTargetUnion$outboundSchema:
  z.ZodType<
    PlanDeploymentComputePublicEndpointTargetUnion$Outbound,
    PlanDeploymentComputePublicEndpointTargetUnion
  > = z.union([
    z.lazy(() =>
      PlanDeploymentComputePublicEndpointTargetLoadBalancer$outboundSchema
    ),
    z.lazy(() =>
      PlanDeploymentComputePublicEndpointTargetMachineAddresses$outboundSchema
    ),
    z.any(),
  ]);

export function planDeploymentComputePublicEndpointTargetUnionToJSON(
  planDeploymentComputePublicEndpointTargetUnion:
    PlanDeploymentComputePublicEndpointTargetUnion,
): string {
  return JSON.stringify(
    PlanDeploymentComputePublicEndpointTargetUnion$outboundSchema.parse(
      planDeploymentComputePublicEndpointTargetUnion,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeDomains$Outbound = {
  customDomains?:
    | { [k: string]: PlanDeploymentComputeCustomDomains$Outbound }
    | null
    | undefined;
  publicEndpointTarget?:
    | PlanDeploymentComputePublicEndpointTargetLoadBalancer$Outbound
    | PlanDeploymentComputePublicEndpointTargetMachineAddresses$Outbound
    | any
    | null
    | undefined;
};

/** @internal */
export const PlanDeploymentComputeDomains$outboundSchema: z.ZodType<
  PlanDeploymentComputeDomains$Outbound,
  PlanDeploymentComputeDomains
> = z.object({
  customDomains: z.nullable(
    z.record(
      z.string(),
      z.lazy(() => PlanDeploymentComputeCustomDomains$outboundSchema),
    ),
  ).optional(),
  publicEndpointTarget: z.nullable(
    z.union([
      z.lazy(() =>
        PlanDeploymentComputePublicEndpointTargetLoadBalancer$outboundSchema
      ),
      z.lazy(() =>
        PlanDeploymentComputePublicEndpointTargetMachineAddresses$outboundSchema
      ),
      z.any(),
    ]),
  ).optional(),
});

export function planDeploymentComputeDomainsToJSON(
  planDeploymentComputeDomains: PlanDeploymentComputeDomains,
): string {
  return JSON.stringify(
    PlanDeploymentComputeDomains$outboundSchema.parse(
      planDeploymentComputeDomains,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeDomainsUnion$Outbound =
  | PlanDeploymentComputeDomains$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeDomainsUnion$outboundSchema: z.ZodType<
  PlanDeploymentComputeDomainsUnion$Outbound,
  PlanDeploymentComputeDomainsUnion
> = z.union([
  z.lazy(() => PlanDeploymentComputeDomains$outboundSchema),
  z.any(),
]);

export function planDeploymentComputeDomainsUnionToJSON(
  planDeploymentComputeDomainsUnion: PlanDeploymentComputeDomainsUnion,
): string {
  return JSON.stringify(
    PlanDeploymentComputeDomainsUnion$outboundSchema.parse(
      planDeploymentComputeDomainsUnion,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeExternalBindings$Outbound = {};

/** @internal */
export const PlanDeploymentComputeExternalBindings$outboundSchema: z.ZodType<
  PlanDeploymentComputeExternalBindings$Outbound,
  PlanDeploymentComputeExternalBindings
> = z.object({});

export function planDeploymentComputeExternalBindingsToJSON(
  planDeploymentComputeExternalBindings: PlanDeploymentComputeExternalBindings,
): string {
  return JSON.stringify(
    PlanDeploymentComputeExternalBindings$outboundSchema.parse(
      planDeploymentComputeExternalBindings,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeHeartbeats$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeHeartbeats
> = z.enum(PlanDeploymentComputeHeartbeats);

/** @internal */
export type PlanDeploymentComputeCloud$Outbound = {
  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;
};

/** @internal */
export const PlanDeploymentComputeCloud$outboundSchema: z.ZodType<
  PlanDeploymentComputeCloud$Outbound,
  PlanDeploymentComputeCloud
> = 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 planDeploymentComputeCloudToJSON(
  planDeploymentComputeCloud: PlanDeploymentComputeCloud,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCloud$outboundSchema.parse(planDeploymentComputeCloud),
  );
}

/** @internal */
export type PlanDeploymentComputeCloudUnion$Outbound =
  | PlanDeploymentComputeCloud$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeCloudUnion$outboundSchema: z.ZodType<
  PlanDeploymentComputeCloudUnion$Outbound,
  PlanDeploymentComputeCloudUnion
> = z.union([z.lazy(() => PlanDeploymentComputeCloud$outboundSchema), z.any()]);

export function planDeploymentComputeCloudUnionToJSON(
  planDeploymentComputeCloudUnion: PlanDeploymentComputeCloudUnion,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCloudUnion$outboundSchema.parse(
      planDeploymentComputeCloudUnion,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeOwnership$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeOwnership
> = z.enum(PlanDeploymentComputeOwnership);

/** @internal */
export type PlanDeploymentComputeCluster$Outbound = {
  cloud?: PlanDeploymentComputeCloud$Outbound | any | null | undefined;
  namespace?: string | null | undefined;
  ownership: string;
};

/** @internal */
export const PlanDeploymentComputeCluster$outboundSchema: z.ZodType<
  PlanDeploymentComputeCluster$Outbound,
  PlanDeploymentComputeCluster
> = z.object({
  cloud: z.nullable(
    z.union([z.lazy(() => PlanDeploymentComputeCloud$outboundSchema), z.any()]),
  ).optional(),
  namespace: z.nullable(z.string()).optional(),
  ownership: PlanDeploymentComputeOwnership$outboundSchema,
});

export function planDeploymentComputeClusterToJSON(
  planDeploymentComputeCluster: PlanDeploymentComputeCluster,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCluster$outboundSchema.parse(
      planDeploymentComputeCluster,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeClusterUnion$Outbound =
  | PlanDeploymentComputeCluster$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeClusterUnion$outboundSchema: z.ZodType<
  PlanDeploymentComputeClusterUnion$Outbound,
  PlanDeploymentComputeClusterUnion
> = z.union([
  z.lazy(() => PlanDeploymentComputeCluster$outboundSchema),
  z.any(),
]);

export function planDeploymentComputeClusterUnionToJSON(
  planDeploymentComputeClusterUnion: PlanDeploymentComputeClusterUnion,
): string {
  return JSON.stringify(
    PlanDeploymentComputeClusterUnion$outboundSchema.parse(
      planDeploymentComputeClusterUnion,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCertificateNone2$Outbound = {
  mode: "none";
};

/** @internal */
export const PlanDeploymentComputeCertificateNone2$outboundSchema: z.ZodType<
  PlanDeploymentComputeCertificateNone2$Outbound,
  PlanDeploymentComputeCertificateNone2
> = z.object({
  mode: z.literal("none"),
});

export function planDeploymentComputeCertificateNone2ToJSON(
  planDeploymentComputeCertificateNone2: PlanDeploymentComputeCertificateNone2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCertificateNone2$outboundSchema.parse(
      planDeploymentComputeCertificateNone2,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCertificateManagedTLSSecret2$Outbound = {
  mode: "managedTlsSecret";
  secretNameTemplate: string;
};

/** @internal */
export const PlanDeploymentComputeCertificateManagedTLSSecret2$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeCertificateManagedTLSSecret2$Outbound,
    PlanDeploymentComputeCertificateManagedTLSSecret2
  > = z.object({
    mode: z.literal("managedTlsSecret"),
    secretNameTemplate: z.string(),
  });

export function planDeploymentComputeCertificateManagedTLSSecret2ToJSON(
  planDeploymentComputeCertificateManagedTLSSecret2:
    PlanDeploymentComputeCertificateManagedTLSSecret2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCertificateManagedTLSSecret2$outboundSchema.parse(
      planDeploymentComputeCertificateManagedTLSSecret2,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCertificateAwsAcmArn2$Outbound = {
  certificateArn: string;
  mode: "awsAcmArn";
};

/** @internal */
export const PlanDeploymentComputeCertificateAwsAcmArn2$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeCertificateAwsAcmArn2$Outbound,
    PlanDeploymentComputeCertificateAwsAcmArn2
  > = z.object({
    certificateArn: z.string(),
    mode: z.literal("awsAcmArn"),
  });

export function planDeploymentComputeCertificateAwsAcmArn2ToJSON(
  planDeploymentComputeCertificateAwsAcmArn2:
    PlanDeploymentComputeCertificateAwsAcmArn2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCertificateAwsAcmArn2$outboundSchema.parse(
      planDeploymentComputeCertificateAwsAcmArn2,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCertificateManagedAcmImport2$Outbound = {
  mode: "managedAcmImport";
  region?: string | null | undefined;
  tags?: { [k: string]: string } | undefined;
};

/** @internal */
export const PlanDeploymentComputeCertificateManagedAcmImport2$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeCertificateManagedAcmImport2$Outbound,
    PlanDeploymentComputeCertificateManagedAcmImport2
  > = z.object({
    mode: z.literal("managedAcmImport"),
    region: z.nullable(z.string()).optional(),
    tags: z.record(z.string(), z.string()).optional(),
  });

export function planDeploymentComputeCertificateManagedAcmImport2ToJSON(
  planDeploymentComputeCertificateManagedAcmImport2:
    PlanDeploymentComputeCertificateManagedAcmImport2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCertificateManagedAcmImport2$outboundSchema.parse(
      planDeploymentComputeCertificateManagedAcmImport2,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCertificateTLSSecretRef2$Outbound = {
  namespace?: string | null | undefined;
  secretName: string;
  mode: "tlsSecretRef";
};

/** @internal */
export const PlanDeploymentComputeCertificateTLSSecretRef2$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeCertificateTLSSecretRef2$Outbound,
    PlanDeploymentComputeCertificateTLSSecretRef2
  > = z.object({
    namespace: z.nullable(z.string()).optional(),
    secretName: z.string(),
    mode: z.literal("tlsSecretRef"),
  });

export function planDeploymentComputeCertificateTLSSecretRef2ToJSON(
  planDeploymentComputeCertificateTLSSecretRef2:
    PlanDeploymentComputeCertificateTLSSecretRef2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCertificateTLSSecretRef2$outboundSchema.parse(
      planDeploymentComputeCertificateTLSSecretRef2,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCertificateUnion2$Outbound =
  | PlanDeploymentComputeCertificateTLSSecretRef2$Outbound
  | PlanDeploymentComputeCertificateManagedAcmImport2$Outbound
  | PlanDeploymentComputeCertificateAwsAcmArn2$Outbound
  | PlanDeploymentComputeCertificateManagedTLSSecret2$Outbound
  | PlanDeploymentComputeCertificateNone2$Outbound;

/** @internal */
export const PlanDeploymentComputeCertificateUnion2$outboundSchema: z.ZodType<
  PlanDeploymentComputeCertificateUnion2$Outbound,
  PlanDeploymentComputeCertificateUnion2
> = z.union([
  z.lazy(() => PlanDeploymentComputeCertificateTLSSecretRef2$outboundSchema),
  z.lazy(() =>
    PlanDeploymentComputeCertificateManagedAcmImport2$outboundSchema
  ),
  z.lazy(() => PlanDeploymentComputeCertificateAwsAcmArn2$outboundSchema),
  z.lazy(() =>
    PlanDeploymentComputeCertificateManagedTLSSecret2$outboundSchema
  ),
  z.lazy(() => PlanDeploymentComputeCertificateNone2$outboundSchema),
]);

export function planDeploymentComputeCertificateUnion2ToJSON(
  planDeploymentComputeCertificateUnion2:
    PlanDeploymentComputeCertificateUnion2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCertificateUnion2$outboundSchema.parse(
      planDeploymentComputeCertificateUnion2,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeModeCustom$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeModeCustom
> = z.enum(PlanDeploymentComputeModeCustom);

/** @internal */
export const PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum4$outboundSchema:
  z.ZodEnum<
    typeof PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum4
  > = z.enum(
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum4,
  );

/** @internal */
export type PlanDeploymentComputeProviderAzureApplicationGatewayForContainers4$Outbound =
  {
    albName?: string | null | undefined;
    albNamespace?: string | null | undefined;
    frontend: string;
    provider: string;
  };

/** @internal */
export const PlanDeploymentComputeProviderAzureApplicationGatewayForContainers4$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers4$Outbound,
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers4
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum4$outboundSchema,
  });

export function planDeploymentComputeProviderAzureApplicationGatewayForContainers4ToJSON(
  planDeploymentComputeProviderAzureApplicationGatewayForContainers4:
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers4,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers4$outboundSchema
      .parse(
        planDeploymentComputeProviderAzureApplicationGatewayForContainers4,
      ),
  );
}

/** @internal */
export const PlanDeploymentComputeProviderGkeGatewayEnum4$outboundSchema:
  z.ZodEnum<typeof PlanDeploymentComputeProviderGkeGatewayEnum4> = z.enum(
    PlanDeploymentComputeProviderGkeGatewayEnum4,
  );

/** @internal */
export type PlanDeploymentComputeProviderGkeGateway4$Outbound = {
  provider: string;
  staticAddressName?: string | null | undefined;
};

/** @internal */
export const PlanDeploymentComputeProviderGkeGateway4$outboundSchema: z.ZodType<
  PlanDeploymentComputeProviderGkeGateway4$Outbound,
  PlanDeploymentComputeProviderGkeGateway4
> = z.object({
  provider: PlanDeploymentComputeProviderGkeGatewayEnum4$outboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function planDeploymentComputeProviderGkeGateway4ToJSON(
  planDeploymentComputeProviderGkeGateway4:
    PlanDeploymentComputeProviderGkeGateway4,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderGkeGateway4$outboundSchema.parse(
      planDeploymentComputeProviderGkeGateway4,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeProviderAwsAlbEnum4$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeProviderAwsAlbEnum4
> = z.enum(PlanDeploymentComputeProviderAwsAlbEnum4);

/** @internal */
export type PlanDeploymentComputeProviderAwsAlb4$Outbound = {
  ipAddressType?: string | null | undefined;
  provider: string;
  scheme: string;
  subnetIds?: Array<string> | undefined;
  targetType: string;
};

/** @internal */
export const PlanDeploymentComputeProviderAwsAlb4$outboundSchema: z.ZodType<
  PlanDeploymentComputeProviderAwsAlb4$Outbound,
  PlanDeploymentComputeProviderAwsAlb4
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: PlanDeploymentComputeProviderAwsAlbEnum4$outboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function planDeploymentComputeProviderAwsAlb4ToJSON(
  planDeploymentComputeProviderAwsAlb4: PlanDeploymentComputeProviderAwsAlb4,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderAwsAlb4$outboundSchema.parse(
      planDeploymentComputeProviderAwsAlb4,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeProviderUnion4$Outbound =
  | PlanDeploymentComputeProviderAwsAlb4$Outbound
  | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers4$Outbound
  | PlanDeploymentComputeProviderGkeGateway4$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeProviderUnion4$outboundSchema: z.ZodType<
  PlanDeploymentComputeProviderUnion4$Outbound,
  PlanDeploymentComputeProviderUnion4
> = z.union([
  z.lazy(() => PlanDeploymentComputeProviderAwsAlb4$outboundSchema),
  z.lazy(() =>
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers4$outboundSchema
  ),
  z.lazy(() => PlanDeploymentComputeProviderGkeGateway4$outboundSchema),
  z.any(),
]);

export function planDeploymentComputeProviderUnion4ToJSON(
  planDeploymentComputeProviderUnion4: PlanDeploymentComputeProviderUnion4,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderUnion4$outboundSchema.parse(
      planDeploymentComputeProviderUnion4,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeRouteGateway2$Outbound = {
  annotations?: { [k: string]: string } | undefined;
  controller?: string | null | undefined;
  gatewayClassName: string;
  labels?: { [k: string]: string } | undefined;
  listenerPort: number;
  provider?:
    | PlanDeploymentComputeProviderAwsAlb4$Outbound
    | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers4$Outbound
    | PlanDeploymentComputeProviderGkeGateway4$Outbound
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

/** @internal */
export const PlanDeploymentComputeRouteGateway2$outboundSchema: z.ZodType<
  PlanDeploymentComputeRouteGateway2$Outbound,
  PlanDeploymentComputeRouteGateway2
> = 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(() => PlanDeploymentComputeProviderAwsAlb4$outboundSchema),
      z.lazy(() =>
        PlanDeploymentComputeProviderAzureApplicationGatewayForContainers4$outboundSchema
      ),
      z.lazy(() => PlanDeploymentComputeProviderGkeGateway4$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

export function planDeploymentComputeRouteGateway2ToJSON(
  planDeploymentComputeRouteGateway2: PlanDeploymentComputeRouteGateway2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeRouteGateway2$outboundSchema.parse(
      planDeploymentComputeRouteGateway2,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum3$outboundSchema:
  z.ZodEnum<
    typeof PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum3
  > = z.enum(
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum3,
  );

/** @internal */
export type PlanDeploymentComputeProviderAzureApplicationGatewayForContainers3$Outbound =
  {
    albName?: string | null | undefined;
    albNamespace?: string | null | undefined;
    frontend: string;
    provider: string;
  };

/** @internal */
export const PlanDeploymentComputeProviderAzureApplicationGatewayForContainers3$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers3$Outbound,
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers3
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum3$outboundSchema,
  });

export function planDeploymentComputeProviderAzureApplicationGatewayForContainers3ToJSON(
  planDeploymentComputeProviderAzureApplicationGatewayForContainers3:
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers3,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers3$outboundSchema
      .parse(
        planDeploymentComputeProviderAzureApplicationGatewayForContainers3,
      ),
  );
}

/** @internal */
export const PlanDeploymentComputeProviderGkeGatewayEnum3$outboundSchema:
  z.ZodEnum<typeof PlanDeploymentComputeProviderGkeGatewayEnum3> = z.enum(
    PlanDeploymentComputeProviderGkeGatewayEnum3,
  );

/** @internal */
export type PlanDeploymentComputeProviderGkeGateway3$Outbound = {
  provider: string;
  staticAddressName?: string | null | undefined;
};

/** @internal */
export const PlanDeploymentComputeProviderGkeGateway3$outboundSchema: z.ZodType<
  PlanDeploymentComputeProviderGkeGateway3$Outbound,
  PlanDeploymentComputeProviderGkeGateway3
> = z.object({
  provider: PlanDeploymentComputeProviderGkeGatewayEnum3$outboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function planDeploymentComputeProviderGkeGateway3ToJSON(
  planDeploymentComputeProviderGkeGateway3:
    PlanDeploymentComputeProviderGkeGateway3,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderGkeGateway3$outboundSchema.parse(
      planDeploymentComputeProviderGkeGateway3,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeProviderAwsAlbEnum3$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeProviderAwsAlbEnum3
> = z.enum(PlanDeploymentComputeProviderAwsAlbEnum3);

/** @internal */
export type PlanDeploymentComputeProviderAwsAlb3$Outbound = {
  ipAddressType?: string | null | undefined;
  provider: string;
  scheme: string;
  subnetIds?: Array<string> | undefined;
  targetType: string;
};

/** @internal */
export const PlanDeploymentComputeProviderAwsAlb3$outboundSchema: z.ZodType<
  PlanDeploymentComputeProviderAwsAlb3$Outbound,
  PlanDeploymentComputeProviderAwsAlb3
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: PlanDeploymentComputeProviderAwsAlbEnum3$outboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function planDeploymentComputeProviderAwsAlb3ToJSON(
  planDeploymentComputeProviderAwsAlb3: PlanDeploymentComputeProviderAwsAlb3,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderAwsAlb3$outboundSchema.parse(
      planDeploymentComputeProviderAwsAlb3,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeProviderUnion3$Outbound =
  | PlanDeploymentComputeProviderAwsAlb3$Outbound
  | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers3$Outbound
  | PlanDeploymentComputeProviderGkeGateway3$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeProviderUnion3$outboundSchema: z.ZodType<
  PlanDeploymentComputeProviderUnion3$Outbound,
  PlanDeploymentComputeProviderUnion3
> = z.union([
  z.lazy(() => PlanDeploymentComputeProviderAwsAlb3$outboundSchema),
  z.lazy(() =>
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers3$outboundSchema
  ),
  z.lazy(() => PlanDeploymentComputeProviderGkeGateway3$outboundSchema),
  z.any(),
]);

export function planDeploymentComputeProviderUnion3ToJSON(
  planDeploymentComputeProviderUnion3: PlanDeploymentComputeProviderUnion3,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderUnion3$outboundSchema.parse(
      planDeploymentComputeProviderUnion3,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeRouteIngress2$Outbound = {
  annotations?: { [k: string]: string } | undefined;
  controller?: string | null | undefined;
  ingressClassName: string;
  labels?: { [k: string]: string } | undefined;
  provider?:
    | PlanDeploymentComputeProviderAwsAlb3$Outbound
    | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers3$Outbound
    | PlanDeploymentComputeProviderGkeGateway3$Outbound
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/** @internal */
export const PlanDeploymentComputeRouteIngress2$outboundSchema: z.ZodType<
  PlanDeploymentComputeRouteIngress2$Outbound,
  PlanDeploymentComputeRouteIngress2
> = 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(() => PlanDeploymentComputeProviderAwsAlb3$outboundSchema),
      z.lazy(() =>
        PlanDeploymentComputeProviderAzureApplicationGatewayForContainers3$outboundSchema
      ),
      z.lazy(() => PlanDeploymentComputeProviderGkeGateway3$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

export function planDeploymentComputeRouteIngress2ToJSON(
  planDeploymentComputeRouteIngress2: PlanDeploymentComputeRouteIngress2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeRouteIngress2$outboundSchema.parse(
      planDeploymentComputeRouteIngress2,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeRouteUnion2$Outbound =
  | PlanDeploymentComputeRouteIngress2$Outbound
  | PlanDeploymentComputeRouteGateway2$Outbound;

/** @internal */
export const PlanDeploymentComputeRouteUnion2$outboundSchema: z.ZodType<
  PlanDeploymentComputeRouteUnion2$Outbound,
  PlanDeploymentComputeRouteUnion2
> = z.union([
  z.lazy(() => PlanDeploymentComputeRouteIngress2$outboundSchema),
  z.lazy(() => PlanDeploymentComputeRouteGateway2$outboundSchema),
]);

export function planDeploymentComputeRouteUnion2ToJSON(
  planDeploymentComputeRouteUnion2: PlanDeploymentComputeRouteUnion2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeRouteUnion2$outboundSchema.parse(
      planDeploymentComputeRouteUnion2,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeExposureCustom$Outbound = {
  certificate:
    | PlanDeploymentComputeCertificateTLSSecretRef2$Outbound
    | PlanDeploymentComputeCertificateManagedAcmImport2$Outbound
    | PlanDeploymentComputeCertificateAwsAcmArn2$Outbound
    | PlanDeploymentComputeCertificateManagedTLSSecret2$Outbound
    | PlanDeploymentComputeCertificateNone2$Outbound;
  domain: string;
  mode: string;
  route:
    | PlanDeploymentComputeRouteIngress2$Outbound
    | PlanDeploymentComputeRouteGateway2$Outbound;
};

/** @internal */
export const PlanDeploymentComputeExposureCustom$outboundSchema: z.ZodType<
  PlanDeploymentComputeExposureCustom$Outbound,
  PlanDeploymentComputeExposureCustom
> = z.object({
  certificate: z.union([
    z.lazy(() => PlanDeploymentComputeCertificateTLSSecretRef2$outboundSchema),
    z.lazy(() =>
      PlanDeploymentComputeCertificateManagedAcmImport2$outboundSchema
    ),
    z.lazy(() => PlanDeploymentComputeCertificateAwsAcmArn2$outboundSchema),
    z.lazy(() =>
      PlanDeploymentComputeCertificateManagedTLSSecret2$outboundSchema
    ),
    z.lazy(() => PlanDeploymentComputeCertificateNone2$outboundSchema),
  ]),
  domain: z.string(),
  mode: PlanDeploymentComputeModeCustom$outboundSchema,
  route: z.union([
    z.lazy(() => PlanDeploymentComputeRouteIngress2$outboundSchema),
    z.lazy(() => PlanDeploymentComputeRouteGateway2$outboundSchema),
  ]),
});

export function planDeploymentComputeExposureCustomToJSON(
  planDeploymentComputeExposureCustom: PlanDeploymentComputeExposureCustom,
): string {
  return JSON.stringify(
    PlanDeploymentComputeExposureCustom$outboundSchema.parse(
      planDeploymentComputeExposureCustom,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCertificateNone1$Outbound = {
  mode: "none";
};

/** @internal */
export const PlanDeploymentComputeCertificateNone1$outboundSchema: z.ZodType<
  PlanDeploymentComputeCertificateNone1$Outbound,
  PlanDeploymentComputeCertificateNone1
> = z.object({
  mode: z.literal("none"),
});

export function planDeploymentComputeCertificateNone1ToJSON(
  planDeploymentComputeCertificateNone1: PlanDeploymentComputeCertificateNone1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCertificateNone1$outboundSchema.parse(
      planDeploymentComputeCertificateNone1,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCertificateManagedTLSSecret1$Outbound = {
  mode: "managedTlsSecret";
  secretNameTemplate: string;
};

/** @internal */
export const PlanDeploymentComputeCertificateManagedTLSSecret1$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeCertificateManagedTLSSecret1$Outbound,
    PlanDeploymentComputeCertificateManagedTLSSecret1
  > = z.object({
    mode: z.literal("managedTlsSecret"),
    secretNameTemplate: z.string(),
  });

export function planDeploymentComputeCertificateManagedTLSSecret1ToJSON(
  planDeploymentComputeCertificateManagedTLSSecret1:
    PlanDeploymentComputeCertificateManagedTLSSecret1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCertificateManagedTLSSecret1$outboundSchema.parse(
      planDeploymentComputeCertificateManagedTLSSecret1,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCertificateAwsAcmArn1$Outbound = {
  certificateArn: string;
  mode: "awsAcmArn";
};

/** @internal */
export const PlanDeploymentComputeCertificateAwsAcmArn1$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeCertificateAwsAcmArn1$Outbound,
    PlanDeploymentComputeCertificateAwsAcmArn1
  > = z.object({
    certificateArn: z.string(),
    mode: z.literal("awsAcmArn"),
  });

export function planDeploymentComputeCertificateAwsAcmArn1ToJSON(
  planDeploymentComputeCertificateAwsAcmArn1:
    PlanDeploymentComputeCertificateAwsAcmArn1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCertificateAwsAcmArn1$outboundSchema.parse(
      planDeploymentComputeCertificateAwsAcmArn1,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCertificateManagedAcmImport1$Outbound = {
  mode: "managedAcmImport";
  region?: string | null | undefined;
  tags?: { [k: string]: string } | undefined;
};

/** @internal */
export const PlanDeploymentComputeCertificateManagedAcmImport1$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeCertificateManagedAcmImport1$Outbound,
    PlanDeploymentComputeCertificateManagedAcmImport1
  > = z.object({
    mode: z.literal("managedAcmImport"),
    region: z.nullable(z.string()).optional(),
    tags: z.record(z.string(), z.string()).optional(),
  });

export function planDeploymentComputeCertificateManagedAcmImport1ToJSON(
  planDeploymentComputeCertificateManagedAcmImport1:
    PlanDeploymentComputeCertificateManagedAcmImport1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCertificateManagedAcmImport1$outboundSchema.parse(
      planDeploymentComputeCertificateManagedAcmImport1,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCertificateTLSSecretRef1$Outbound = {
  namespace?: string | null | undefined;
  secretName: string;
  mode: "tlsSecretRef";
};

/** @internal */
export const PlanDeploymentComputeCertificateTLSSecretRef1$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeCertificateTLSSecretRef1$Outbound,
    PlanDeploymentComputeCertificateTLSSecretRef1
  > = z.object({
    namespace: z.nullable(z.string()).optional(),
    secretName: z.string(),
    mode: z.literal("tlsSecretRef"),
  });

export function planDeploymentComputeCertificateTLSSecretRef1ToJSON(
  planDeploymentComputeCertificateTLSSecretRef1:
    PlanDeploymentComputeCertificateTLSSecretRef1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCertificateTLSSecretRef1$outboundSchema.parse(
      planDeploymentComputeCertificateTLSSecretRef1,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeCertificateUnion1$Outbound =
  | PlanDeploymentComputeCertificateTLSSecretRef1$Outbound
  | PlanDeploymentComputeCertificateManagedAcmImport1$Outbound
  | PlanDeploymentComputeCertificateAwsAcmArn1$Outbound
  | PlanDeploymentComputeCertificateManagedTLSSecret1$Outbound
  | PlanDeploymentComputeCertificateNone1$Outbound;

/** @internal */
export const PlanDeploymentComputeCertificateUnion1$outboundSchema: z.ZodType<
  PlanDeploymentComputeCertificateUnion1$Outbound,
  PlanDeploymentComputeCertificateUnion1
> = z.union([
  z.lazy(() => PlanDeploymentComputeCertificateTLSSecretRef1$outboundSchema),
  z.lazy(() =>
    PlanDeploymentComputeCertificateManagedAcmImport1$outboundSchema
  ),
  z.lazy(() => PlanDeploymentComputeCertificateAwsAcmArn1$outboundSchema),
  z.lazy(() =>
    PlanDeploymentComputeCertificateManagedTLSSecret1$outboundSchema
  ),
  z.lazy(() => PlanDeploymentComputeCertificateNone1$outboundSchema),
]);

export function planDeploymentComputeCertificateUnion1ToJSON(
  planDeploymentComputeCertificateUnion1:
    PlanDeploymentComputeCertificateUnion1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeCertificateUnion1$outboundSchema.parse(
      planDeploymentComputeCertificateUnion1,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeModeGenerated$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeModeGenerated
> = z.enum(PlanDeploymentComputeModeGenerated);

/** @internal */
export const PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum2$outboundSchema:
  z.ZodEnum<
    typeof PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum2
  > = z.enum(
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum2,
  );

/** @internal */
export type PlanDeploymentComputeProviderAzureApplicationGatewayForContainers2$Outbound =
  {
    albName?: string | null | undefined;
    albNamespace?: string | null | undefined;
    frontend: string;
    provider: string;
  };

/** @internal */
export const PlanDeploymentComputeProviderAzureApplicationGatewayForContainers2$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers2$Outbound,
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers2
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum2$outboundSchema,
  });

export function planDeploymentComputeProviderAzureApplicationGatewayForContainers2ToJSON(
  planDeploymentComputeProviderAzureApplicationGatewayForContainers2:
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers2$outboundSchema
      .parse(
        planDeploymentComputeProviderAzureApplicationGatewayForContainers2,
      ),
  );
}

/** @internal */
export const PlanDeploymentComputeProviderGkeGatewayEnum2$outboundSchema:
  z.ZodEnum<typeof PlanDeploymentComputeProviderGkeGatewayEnum2> = z.enum(
    PlanDeploymentComputeProviderGkeGatewayEnum2,
  );

/** @internal */
export type PlanDeploymentComputeProviderGkeGateway2$Outbound = {
  provider: string;
  staticAddressName?: string | null | undefined;
};

/** @internal */
export const PlanDeploymentComputeProviderGkeGateway2$outboundSchema: z.ZodType<
  PlanDeploymentComputeProviderGkeGateway2$Outbound,
  PlanDeploymentComputeProviderGkeGateway2
> = z.object({
  provider: PlanDeploymentComputeProviderGkeGatewayEnum2$outboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function planDeploymentComputeProviderGkeGateway2ToJSON(
  planDeploymentComputeProviderGkeGateway2:
    PlanDeploymentComputeProviderGkeGateway2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderGkeGateway2$outboundSchema.parse(
      planDeploymentComputeProviderGkeGateway2,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeProviderAwsAlbEnum2$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeProviderAwsAlbEnum2
> = z.enum(PlanDeploymentComputeProviderAwsAlbEnum2);

/** @internal */
export type PlanDeploymentComputeProviderAwsAlb2$Outbound = {
  ipAddressType?: string | null | undefined;
  provider: string;
  scheme: string;
  subnetIds?: Array<string> | undefined;
  targetType: string;
};

/** @internal */
export const PlanDeploymentComputeProviderAwsAlb2$outboundSchema: z.ZodType<
  PlanDeploymentComputeProviderAwsAlb2$Outbound,
  PlanDeploymentComputeProviderAwsAlb2
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: PlanDeploymentComputeProviderAwsAlbEnum2$outboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function planDeploymentComputeProviderAwsAlb2ToJSON(
  planDeploymentComputeProviderAwsAlb2: PlanDeploymentComputeProviderAwsAlb2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderAwsAlb2$outboundSchema.parse(
      planDeploymentComputeProviderAwsAlb2,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeProviderUnion2$Outbound =
  | PlanDeploymentComputeProviderAwsAlb2$Outbound
  | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers2$Outbound
  | PlanDeploymentComputeProviderGkeGateway2$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeProviderUnion2$outboundSchema: z.ZodType<
  PlanDeploymentComputeProviderUnion2$Outbound,
  PlanDeploymentComputeProviderUnion2
> = z.union([
  z.lazy(() => PlanDeploymentComputeProviderAwsAlb2$outboundSchema),
  z.lazy(() =>
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers2$outboundSchema
  ),
  z.lazy(() => PlanDeploymentComputeProviderGkeGateway2$outboundSchema),
  z.any(),
]);

export function planDeploymentComputeProviderUnion2ToJSON(
  planDeploymentComputeProviderUnion2: PlanDeploymentComputeProviderUnion2,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderUnion2$outboundSchema.parse(
      planDeploymentComputeProviderUnion2,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeRouteGateway1$Outbound = {
  annotations?: { [k: string]: string } | undefined;
  controller?: string | null | undefined;
  gatewayClassName: string;
  labels?: { [k: string]: string } | undefined;
  listenerPort: number;
  provider?:
    | PlanDeploymentComputeProviderAwsAlb2$Outbound
    | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers2$Outbound
    | PlanDeploymentComputeProviderGkeGateway2$Outbound
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

/** @internal */
export const PlanDeploymentComputeRouteGateway1$outboundSchema: z.ZodType<
  PlanDeploymentComputeRouteGateway1$Outbound,
  PlanDeploymentComputeRouteGateway1
> = 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(() => PlanDeploymentComputeProviderAwsAlb2$outboundSchema),
      z.lazy(() =>
        PlanDeploymentComputeProviderAzureApplicationGatewayForContainers2$outboundSchema
      ),
      z.lazy(() => PlanDeploymentComputeProviderGkeGateway2$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

export function planDeploymentComputeRouteGateway1ToJSON(
  planDeploymentComputeRouteGateway1: PlanDeploymentComputeRouteGateway1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeRouteGateway1$outboundSchema.parse(
      planDeploymentComputeRouteGateway1,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum1$outboundSchema:
  z.ZodEnum<
    typeof PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum1
  > = z.enum(
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum1,
  );

/** @internal */
export type PlanDeploymentComputeProviderAzureApplicationGatewayForContainers1$Outbound =
  {
    albName?: string | null | undefined;
    albNamespace?: string | null | undefined;
    frontend: string;
    provider: string;
  };

/** @internal */
export const PlanDeploymentComputeProviderAzureApplicationGatewayForContainers1$outboundSchema:
  z.ZodType<
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers1$Outbound,
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers1
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      PlanDeploymentComputeProviderAzureApplicationGatewayForContainersEnum1$outboundSchema,
  });

export function planDeploymentComputeProviderAzureApplicationGatewayForContainers1ToJSON(
  planDeploymentComputeProviderAzureApplicationGatewayForContainers1:
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers1$outboundSchema
      .parse(
        planDeploymentComputeProviderAzureApplicationGatewayForContainers1,
      ),
  );
}

/** @internal */
export const PlanDeploymentComputeProviderGkeGatewayEnum1$outboundSchema:
  z.ZodEnum<typeof PlanDeploymentComputeProviderGkeGatewayEnum1> = z.enum(
    PlanDeploymentComputeProviderGkeGatewayEnum1,
  );

/** @internal */
export type PlanDeploymentComputeProviderGkeGateway1$Outbound = {
  provider: string;
  staticAddressName?: string | null | undefined;
};

/** @internal */
export const PlanDeploymentComputeProviderGkeGateway1$outboundSchema: z.ZodType<
  PlanDeploymentComputeProviderGkeGateway1$Outbound,
  PlanDeploymentComputeProviderGkeGateway1
> = z.object({
  provider: PlanDeploymentComputeProviderGkeGatewayEnum1$outboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function planDeploymentComputeProviderGkeGateway1ToJSON(
  planDeploymentComputeProviderGkeGateway1:
    PlanDeploymentComputeProviderGkeGateway1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderGkeGateway1$outboundSchema.parse(
      planDeploymentComputeProviderGkeGateway1,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeProviderAwsAlbEnum1$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeProviderAwsAlbEnum1
> = z.enum(PlanDeploymentComputeProviderAwsAlbEnum1);

/** @internal */
export type PlanDeploymentComputeProviderAwsAlb1$Outbound = {
  ipAddressType?: string | null | undefined;
  provider: string;
  scheme: string;
  subnetIds?: Array<string> | undefined;
  targetType: string;
};

/** @internal */
export const PlanDeploymentComputeProviderAwsAlb1$outboundSchema: z.ZodType<
  PlanDeploymentComputeProviderAwsAlb1$Outbound,
  PlanDeploymentComputeProviderAwsAlb1
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: PlanDeploymentComputeProviderAwsAlbEnum1$outboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function planDeploymentComputeProviderAwsAlb1ToJSON(
  planDeploymentComputeProviderAwsAlb1: PlanDeploymentComputeProviderAwsAlb1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderAwsAlb1$outboundSchema.parse(
      planDeploymentComputeProviderAwsAlb1,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeProviderUnion1$Outbound =
  | PlanDeploymentComputeProviderAwsAlb1$Outbound
  | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers1$Outbound
  | PlanDeploymentComputeProviderGkeGateway1$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeProviderUnion1$outboundSchema: z.ZodType<
  PlanDeploymentComputeProviderUnion1$Outbound,
  PlanDeploymentComputeProviderUnion1
> = z.union([
  z.lazy(() => PlanDeploymentComputeProviderAwsAlb1$outboundSchema),
  z.lazy(() =>
    PlanDeploymentComputeProviderAzureApplicationGatewayForContainers1$outboundSchema
  ),
  z.lazy(() => PlanDeploymentComputeProviderGkeGateway1$outboundSchema),
  z.any(),
]);

export function planDeploymentComputeProviderUnion1ToJSON(
  planDeploymentComputeProviderUnion1: PlanDeploymentComputeProviderUnion1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeProviderUnion1$outboundSchema.parse(
      planDeploymentComputeProviderUnion1,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeRouteIngress1$Outbound = {
  annotations?: { [k: string]: string } | undefined;
  controller?: string | null | undefined;
  ingressClassName: string;
  labels?: { [k: string]: string } | undefined;
  provider?:
    | PlanDeploymentComputeProviderAwsAlb1$Outbound
    | PlanDeploymentComputeProviderAzureApplicationGatewayForContainers1$Outbound
    | PlanDeploymentComputeProviderGkeGateway1$Outbound
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/** @internal */
export const PlanDeploymentComputeRouteIngress1$outboundSchema: z.ZodType<
  PlanDeploymentComputeRouteIngress1$Outbound,
  PlanDeploymentComputeRouteIngress1
> = 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(() => PlanDeploymentComputeProviderAwsAlb1$outboundSchema),
      z.lazy(() =>
        PlanDeploymentComputeProviderAzureApplicationGatewayForContainers1$outboundSchema
      ),
      z.lazy(() => PlanDeploymentComputeProviderGkeGateway1$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

export function planDeploymentComputeRouteIngress1ToJSON(
  planDeploymentComputeRouteIngress1: PlanDeploymentComputeRouteIngress1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeRouteIngress1$outboundSchema.parse(
      planDeploymentComputeRouteIngress1,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeRouteUnion1$Outbound =
  | PlanDeploymentComputeRouteIngress1$Outbound
  | PlanDeploymentComputeRouteGateway1$Outbound;

/** @internal */
export const PlanDeploymentComputeRouteUnion1$outboundSchema: z.ZodType<
  PlanDeploymentComputeRouteUnion1$Outbound,
  PlanDeploymentComputeRouteUnion1
> = z.union([
  z.lazy(() => PlanDeploymentComputeRouteIngress1$outboundSchema),
  z.lazy(() => PlanDeploymentComputeRouteGateway1$outboundSchema),
]);

export function planDeploymentComputeRouteUnion1ToJSON(
  planDeploymentComputeRouteUnion1: PlanDeploymentComputeRouteUnion1,
): string {
  return JSON.stringify(
    PlanDeploymentComputeRouteUnion1$outboundSchema.parse(
      planDeploymentComputeRouteUnion1,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeExposureGenerated$Outbound = {
  certificate:
    | PlanDeploymentComputeCertificateTLSSecretRef1$Outbound
    | PlanDeploymentComputeCertificateManagedAcmImport1$Outbound
    | PlanDeploymentComputeCertificateAwsAcmArn1$Outbound
    | PlanDeploymentComputeCertificateManagedTLSSecret1$Outbound
    | PlanDeploymentComputeCertificateNone1$Outbound;
  mode: string;
  route:
    | PlanDeploymentComputeRouteIngress1$Outbound
    | PlanDeploymentComputeRouteGateway1$Outbound;
};

/** @internal */
export const PlanDeploymentComputeExposureGenerated$outboundSchema: z.ZodType<
  PlanDeploymentComputeExposureGenerated$Outbound,
  PlanDeploymentComputeExposureGenerated
> = z.object({
  certificate: z.union([
    z.lazy(() => PlanDeploymentComputeCertificateTLSSecretRef1$outboundSchema),
    z.lazy(() =>
      PlanDeploymentComputeCertificateManagedAcmImport1$outboundSchema
    ),
    z.lazy(() => PlanDeploymentComputeCertificateAwsAcmArn1$outboundSchema),
    z.lazy(() =>
      PlanDeploymentComputeCertificateManagedTLSSecret1$outboundSchema
    ),
    z.lazy(() => PlanDeploymentComputeCertificateNone1$outboundSchema),
  ]),
  mode: PlanDeploymentComputeModeGenerated$outboundSchema,
  route: z.union([
    z.lazy(() => PlanDeploymentComputeRouteIngress1$outboundSchema),
    z.lazy(() => PlanDeploymentComputeRouteGateway1$outboundSchema),
  ]),
});

export function planDeploymentComputeExposureGeneratedToJSON(
  planDeploymentComputeExposureGenerated:
    PlanDeploymentComputeExposureGenerated,
): string {
  return JSON.stringify(
    PlanDeploymentComputeExposureGenerated$outboundSchema.parse(
      planDeploymentComputeExposureGenerated,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeModeDisabled$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeModeDisabled
> = z.enum(PlanDeploymentComputeModeDisabled);

/** @internal */
export type PlanDeploymentComputeExposureDisabled$Outbound = {
  mode: string;
};

/** @internal */
export const PlanDeploymentComputeExposureDisabled$outboundSchema: z.ZodType<
  PlanDeploymentComputeExposureDisabled$Outbound,
  PlanDeploymentComputeExposureDisabled
> = z.object({
  mode: PlanDeploymentComputeModeDisabled$outboundSchema,
});

export function planDeploymentComputeExposureDisabledToJSON(
  planDeploymentComputeExposureDisabled: PlanDeploymentComputeExposureDisabled,
): string {
  return JSON.stringify(
    PlanDeploymentComputeExposureDisabled$outboundSchema.parse(
      planDeploymentComputeExposureDisabled,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeExposureUnion$Outbound =
  | PlanDeploymentComputeExposureCustom$Outbound
  | PlanDeploymentComputeExposureGenerated$Outbound
  | PlanDeploymentComputeExposureDisabled$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeExposureUnion$outboundSchema: z.ZodType<
  PlanDeploymentComputeExposureUnion$Outbound,
  PlanDeploymentComputeExposureUnion
> = z.union([
  z.lazy(() => PlanDeploymentComputeExposureCustom$outboundSchema),
  z.lazy(() => PlanDeploymentComputeExposureGenerated$outboundSchema),
  z.lazy(() => PlanDeploymentComputeExposureDisabled$outboundSchema),
  z.any(),
]);

export function planDeploymentComputeExposureUnionToJSON(
  planDeploymentComputeExposureUnion: PlanDeploymentComputeExposureUnion,
): string {
  return JSON.stringify(
    PlanDeploymentComputeExposureUnion$outboundSchema.parse(
      planDeploymentComputeExposureUnion,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeKubernetes$Outbound = {
  cluster?: PlanDeploymentComputeCluster$Outbound | any | null | undefined;
  exposure?:
    | PlanDeploymentComputeExposureCustom$Outbound
    | PlanDeploymentComputeExposureGenerated$Outbound
    | PlanDeploymentComputeExposureDisabled$Outbound
    | any
    | null
    | undefined;
};

/** @internal */
export const PlanDeploymentComputeKubernetes$outboundSchema: z.ZodType<
  PlanDeploymentComputeKubernetes$Outbound,
  PlanDeploymentComputeKubernetes
> = z.object({
  cluster: z.nullable(
    z.union([
      z.lazy(() => PlanDeploymentComputeCluster$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  exposure: z.nullable(
    z.union([
      z.lazy(() => PlanDeploymentComputeExposureCustom$outboundSchema),
      z.lazy(() => PlanDeploymentComputeExposureGenerated$outboundSchema),
      z.lazy(() => PlanDeploymentComputeExposureDisabled$outboundSchema),
      z.any(),
    ]),
  ).optional(),
});

export function planDeploymentComputeKubernetesToJSON(
  planDeploymentComputeKubernetes: PlanDeploymentComputeKubernetes,
): string {
  return JSON.stringify(
    PlanDeploymentComputeKubernetes$outboundSchema.parse(
      planDeploymentComputeKubernetes,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeKubernetesUnion$Outbound =
  | PlanDeploymentComputeKubernetes$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeKubernetesUnion$outboundSchema: z.ZodType<
  PlanDeploymentComputeKubernetesUnion$Outbound,
  PlanDeploymentComputeKubernetesUnion
> = z.union([
  z.lazy(() => PlanDeploymentComputeKubernetes$outboundSchema),
  z.any(),
]);

export function planDeploymentComputeKubernetesUnionToJSON(
  planDeploymentComputeKubernetesUnion: PlanDeploymentComputeKubernetesUnion,
): string {
  return JSON.stringify(
    PlanDeploymentComputeKubernetesUnion$outboundSchema.parse(
      planDeploymentComputeKubernetesUnion,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeTypeByoVnetAzure$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeTypeByoVnetAzure
> = z.enum(PlanDeploymentComputeTypeByoVnetAzure);

/** @internal */
export type PlanDeploymentComputeNetworkByoVnetAzure$Outbound = {
  application_gateway_subnet_name?: string | null | undefined;
  private_endpoint_subnet_name?: string | null | undefined;
  private_subnet_name: string;
  public_subnet_name: string;
  type: string;
  vnet_resource_id: string;
};

/** @internal */
export const PlanDeploymentComputeNetworkByoVnetAzure$outboundSchema: z.ZodType<
  PlanDeploymentComputeNetworkByoVnetAzure$Outbound,
  PlanDeploymentComputeNetworkByoVnetAzure
> = z.object({
  applicationGatewaySubnetName: z.nullable(z.string()).optional(),
  privateEndpointSubnetName: z.nullable(z.string()).optional(),
  privateSubnetName: z.string(),
  publicSubnetName: z.string(),
  type: PlanDeploymentComputeTypeByoVnetAzure$outboundSchema,
  vnetResourceId: z.string(),
}).transform((v) => {
  return remap$(v, {
    applicationGatewaySubnetName: "application_gateway_subnet_name",
    privateEndpointSubnetName: "private_endpoint_subnet_name",
    privateSubnetName: "private_subnet_name",
    publicSubnetName: "public_subnet_name",
    vnetResourceId: "vnet_resource_id",
  });
});

export function planDeploymentComputeNetworkByoVnetAzureToJSON(
  planDeploymentComputeNetworkByoVnetAzure:
    PlanDeploymentComputeNetworkByoVnetAzure,
): string {
  return JSON.stringify(
    PlanDeploymentComputeNetworkByoVnetAzure$outboundSchema.parse(
      planDeploymentComputeNetworkByoVnetAzure,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeTypeByoVpcGcp$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeTypeByoVpcGcp
> = z.enum(PlanDeploymentComputeTypeByoVpcGcp);

/** @internal */
export type PlanDeploymentComputeNetworkByoVpcGcp$Outbound = {
  network_name: string;
  region: string;
  subnet_name: string;
  type: string;
};

/** @internal */
export const PlanDeploymentComputeNetworkByoVpcGcp$outboundSchema: z.ZodType<
  PlanDeploymentComputeNetworkByoVpcGcp$Outbound,
  PlanDeploymentComputeNetworkByoVpcGcp
> = z.object({
  networkName: z.string(),
  region: z.string(),
  subnetName: z.string(),
  type: PlanDeploymentComputeTypeByoVpcGcp$outboundSchema,
}).transform((v) => {
  return remap$(v, {
    networkName: "network_name",
    subnetName: "subnet_name",
  });
});

export function planDeploymentComputeNetworkByoVpcGcpToJSON(
  planDeploymentComputeNetworkByoVpcGcp: PlanDeploymentComputeNetworkByoVpcGcp,
): string {
  return JSON.stringify(
    PlanDeploymentComputeNetworkByoVpcGcp$outboundSchema.parse(
      planDeploymentComputeNetworkByoVpcGcp,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeTypeByoVpcAws$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeTypeByoVpcAws
> = z.enum(PlanDeploymentComputeTypeByoVpcAws);

/** @internal */
export type PlanDeploymentComputeNetworkByoVpcAws$Outbound = {
  private_subnet_ids: Array<string>;
  public_subnet_ids: Array<string>;
  security_group_ids?: Array<string> | undefined;
  type: string;
  vpc_id: string;
};

/** @internal */
export const PlanDeploymentComputeNetworkByoVpcAws$outboundSchema: z.ZodType<
  PlanDeploymentComputeNetworkByoVpcAws$Outbound,
  PlanDeploymentComputeNetworkByoVpcAws
> = z.object({
  privateSubnetIds: z.array(z.string()),
  publicSubnetIds: z.array(z.string()),
  securityGroupIds: z.array(z.string()).optional(),
  type: PlanDeploymentComputeTypeByoVpcAws$outboundSchema,
  vpcId: z.string(),
}).transform((v) => {
  return remap$(v, {
    privateSubnetIds: "private_subnet_ids",
    publicSubnetIds: "public_subnet_ids",
    securityGroupIds: "security_group_ids",
    vpcId: "vpc_id",
  });
});

export function planDeploymentComputeNetworkByoVpcAwsToJSON(
  planDeploymentComputeNetworkByoVpcAws: PlanDeploymentComputeNetworkByoVpcAws,
): string {
  return JSON.stringify(
    PlanDeploymentComputeNetworkByoVpcAws$outboundSchema.parse(
      planDeploymentComputeNetworkByoVpcAws,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeTypeCreate$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeTypeCreate
> = z.enum(PlanDeploymentComputeTypeCreate);

/** @internal */
export type PlanDeploymentComputeNetworkCreate$Outbound = {
  availability_zones?: number | undefined;
  cidr?: string | null | undefined;
  type: string;
};

/** @internal */
export const PlanDeploymentComputeNetworkCreate$outboundSchema: z.ZodType<
  PlanDeploymentComputeNetworkCreate$Outbound,
  PlanDeploymentComputeNetworkCreate
> = z.object({
  availabilityZones: z.int().optional(),
  cidr: z.nullable(z.string()).optional(),
  type: PlanDeploymentComputeTypeCreate$outboundSchema,
}).transform((v) => {
  return remap$(v, {
    availabilityZones: "availability_zones",
  });
});

export function planDeploymentComputeNetworkCreateToJSON(
  planDeploymentComputeNetworkCreate: PlanDeploymentComputeNetworkCreate,
): string {
  return JSON.stringify(
    PlanDeploymentComputeNetworkCreate$outboundSchema.parse(
      planDeploymentComputeNetworkCreate,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeTypeUseDefault$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeTypeUseDefault
> = z.enum(PlanDeploymentComputeTypeUseDefault);

/** @internal */
export type PlanDeploymentComputeNetworkUseDefault$Outbound = {
  type: string;
};

/** @internal */
export const PlanDeploymentComputeNetworkUseDefault$outboundSchema: z.ZodType<
  PlanDeploymentComputeNetworkUseDefault$Outbound,
  PlanDeploymentComputeNetworkUseDefault
> = z.object({
  type: PlanDeploymentComputeTypeUseDefault$outboundSchema,
});

export function planDeploymentComputeNetworkUseDefaultToJSON(
  planDeploymentComputeNetworkUseDefault:
    PlanDeploymentComputeNetworkUseDefault,
): string {
  return JSON.stringify(
    PlanDeploymentComputeNetworkUseDefault$outboundSchema.parse(
      planDeploymentComputeNetworkUseDefault,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeNetworkUnion$Outbound =
  | PlanDeploymentComputeNetworkByoVpcAws$Outbound
  | PlanDeploymentComputeNetworkByoVpcGcp$Outbound
  | PlanDeploymentComputeNetworkByoVnetAzure$Outbound
  | PlanDeploymentComputeNetworkUseDefault$Outbound
  | PlanDeploymentComputeNetworkCreate$Outbound
  | any;

/** @internal */
export const PlanDeploymentComputeNetworkUnion$outboundSchema: z.ZodType<
  PlanDeploymentComputeNetworkUnion$Outbound,
  PlanDeploymentComputeNetworkUnion
> = z.union([
  z.lazy(() => PlanDeploymentComputeNetworkByoVpcAws$outboundSchema),
  z.lazy(() => PlanDeploymentComputeNetworkByoVpcGcp$outboundSchema),
  z.lazy(() => PlanDeploymentComputeNetworkByoVnetAzure$outboundSchema),
  z.lazy(() => PlanDeploymentComputeNetworkUseDefault$outboundSchema),
  z.lazy(() => PlanDeploymentComputeNetworkCreate$outboundSchema),
  z.any(),
]);

export function planDeploymentComputeNetworkUnionToJSON(
  planDeploymentComputeNetworkUnion: PlanDeploymentComputeNetworkUnion,
): string {
  return JSON.stringify(
    PlanDeploymentComputeNetworkUnion$outboundSchema.parse(
      planDeploymentComputeNetworkUnion,
    ),
  );
}

/** @internal */
export const PlanDeploymentComputeTelemetry$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeTelemetry
> = z.enum(PlanDeploymentComputeTelemetry);

/** @internal */
export const PlanDeploymentComputeUpdates$outboundSchema: z.ZodEnum<
  typeof PlanDeploymentComputeUpdates
> = z.enum(PlanDeploymentComputeUpdates);

/** @internal */
export type PlanDeploymentComputeStackSettings$Outbound = {
  compute?: PlanDeploymentComputeCompute$Outbound | any | null | undefined;
  deploymentModel?: string | undefined;
  domains?: PlanDeploymentComputeDomains$Outbound | any | null | undefined;
  externalBindings?:
    | PlanDeploymentComputeExternalBindings$Outbound
    | null
    | undefined;
  heartbeats?: string | undefined;
  kubernetes?:
    | PlanDeploymentComputeKubernetes$Outbound
    | any
    | null
    | undefined;
  network?:
    | PlanDeploymentComputeNetworkByoVpcAws$Outbound
    | PlanDeploymentComputeNetworkByoVpcGcp$Outbound
    | PlanDeploymentComputeNetworkByoVnetAzure$Outbound
    | PlanDeploymentComputeNetworkUseDefault$Outbound
    | PlanDeploymentComputeNetworkCreate$Outbound
    | any
    | null
    | undefined;
  publicEndpoints?: { [k: string]: { [k: string]: string } } | null | undefined;
  telemetry?: string | undefined;
  updates?: string | undefined;
};

/** @internal */
export const PlanDeploymentComputeStackSettings$outboundSchema: z.ZodType<
  PlanDeploymentComputeStackSettings$Outbound,
  PlanDeploymentComputeStackSettings
> = z.object({
  compute: z.nullable(
    z.union([
      z.lazy(() => PlanDeploymentComputeCompute$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  deploymentModel: PlanDeploymentComputeDeploymentModel$outboundSchema
    .optional(),
  domains: z.nullable(
    z.union([
      z.lazy(() => PlanDeploymentComputeDomains$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  externalBindings: z.nullable(
    z.lazy(() => PlanDeploymentComputeExternalBindings$outboundSchema),
  ).optional(),
  heartbeats: PlanDeploymentComputeHeartbeats$outboundSchema.optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => PlanDeploymentComputeKubernetes$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  network: z.nullable(
    z.union([
      z.lazy(() => PlanDeploymentComputeNetworkByoVpcAws$outboundSchema),
      z.lazy(() => PlanDeploymentComputeNetworkByoVpcGcp$outboundSchema),
      z.lazy(() => PlanDeploymentComputeNetworkByoVnetAzure$outboundSchema),
      z.lazy(() => PlanDeploymentComputeNetworkUseDefault$outboundSchema),
      z.lazy(() => PlanDeploymentComputeNetworkCreate$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  publicEndpoints: z.nullable(
    z.record(z.string(), z.record(z.string(), z.string())),
  ).optional(),
  telemetry: PlanDeploymentComputeTelemetry$outboundSchema.optional(),
  updates: PlanDeploymentComputeUpdates$outboundSchema.optional(),
});

export function planDeploymentComputeStackSettingsToJSON(
  planDeploymentComputeStackSettings: PlanDeploymentComputeStackSettings,
): string {
  return JSON.stringify(
    PlanDeploymentComputeStackSettings$outboundSchema.parse(
      planDeploymentComputeStackSettings,
    ),
  );
}

/** @internal */
export type PlanDeploymentComputeRequest$Outbound = {
  setupItem?: string | undefined;
  deploymentId?: string | undefined;
  updateOperationId?: string | undefined;
  platform: string;
  setupMethod: string;
  region?: string | undefined;
  stackSettings: PlanDeploymentComputeStackSettings$Outbound;
};

/** @internal */
export const PlanDeploymentComputeRequest$outboundSchema: z.ZodType<
  PlanDeploymentComputeRequest$Outbound,
  PlanDeploymentComputeRequest
> = z.object({
  setupItem: PlanDeploymentComputeSetupItem$outboundSchema.optional(),
  deploymentId: z.string().optional(),
  updateOperationId: z.string().optional(),
  platform: PlanDeploymentComputePlatform$outboundSchema,
  setupMethod: models.DeploymentSetupMethod$outboundSchema,
  region: z.string().optional(),
  stackSettings: z.lazy(() =>
    PlanDeploymentComputeStackSettings$outboundSchema
  ),
});

export function planDeploymentComputeRequestToJSON(
  planDeploymentComputeRequest: PlanDeploymentComputeRequest,
): string {
  return JSON.stringify(
    PlanDeploymentComputeRequest$outboundSchema.parse(
      planDeploymentComputeRequest,
    ),
  );
}