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

import * as z from "zod/v4";
import { remap as remap$ } from "../lib/primitives.js";
import { ClosedEnum } from "../types/enums.js";
import {
  ImportedResource,
  ImportedResource$Outbound,
  ImportedResource$outboundSchema,
} from "./importedresource.js";
import {
  ImportSourceKind,
  ImportSourceKind$outboundSchema,
} from "./importsourcekind.js";
import {
  KubernetesBasePlatform,
  KubernetesBasePlatform$outboundSchema,
} from "./kubernetesbaseplatform.js";

/**
 * Cloud platform of the imported stack
 */
export const ImportSourcePlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Local: "local",
  Test: "test",
} as const;
/**
 * Cloud platform of the imported stack
 */
export type ImportSourcePlatform = ClosedEnum<typeof ImportSourcePlatform>;

/**
 * Failure-domain policy selected for a compute pool.
 */
export type ImportSourceFailureDomains2 = {
  /**
   * 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 ImportSourceFailureDomainsUnion2 =
  | ImportSourceFailureDomains2
  | any;

export type ImportSourcePoolsAutoscale = {
  failureDomains?: ImportSourceFailureDomains2 | 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 ImportSourceFailureDomains1 = {
  /**
   * 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 ImportSourceFailureDomainsUnion1 =
  | ImportSourceFailureDomains1
  | any;

export type ImportSourcePoolsFixed = {
  failureDomains?: ImportSourceFailureDomains1 | 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 ImportSourcePoolsUnion =
  | ImportSourcePoolsFixed
  | ImportSourcePoolsAutoscale;

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

export type ImportSourceComputeUnion = ImportSourceCompute | any;

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

export type ImportSourceAws = {
  certificateArn: string;
};

export type ImportSourceAwsUnion = ImportSourceAws | any;

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

export type ImportSourceAzureUnion = ImportSourceAzure | any;

export type ImportSourceGcp = {
  certificateName: string;
};

export type ImportSourceGcpUnion = ImportSourceGcp | any;

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

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

export type ImportSourceDomainsKubernetesUnion =
  | ImportSourceDomainsKubernetes
  | any;

/**
 * Platform-specific certificate references for custom domains.
 */
export type ImportSourceDomainsCertificate = {
  aws?: ImportSourceAws | any | null | undefined;
  azure?: ImportSourceAzure | any | null | undefined;
  gcp?: ImportSourceGcp | any | null | undefined;
  kubernetes?: ImportSourceDomainsKubernetes | any | null | undefined;
};

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

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

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

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

export type ImportSourcePublicEndpointTargetMachineAddresses = {
  mode: ImportSourceModeMachineAddresses;
};

export type ImportSourcePublicEndpointTargetUnion =
  | ImportSourcePublicEndpointTargetLoadBalancer
  | ImportSourcePublicEndpointTargetMachineAddresses
  | 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 ImportSourceDomains = {
  /**
   * Custom domain configuration per resource ID.
   */
  customDomains?: { [k: string]: ImportSourceCustomDomains } | null | undefined;
  publicEndpointTarget?:
    | ImportSourcePublicEndpointTargetLoadBalancer
    | ImportSourcePublicEndpointTargetMachineAddresses
    | any
    | null
    | undefined;
};

export type ImportSourceDomainsUnion = ImportSourceDomains | 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 ImportSourceExternalBindings = {};

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

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

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

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

export type ImportSourceClusterUnion = ImportSourceCluster | any;

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

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

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

export type ImportSourceCertificateManagedAcmImport2 = {
  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 ImportSourceCertificateTLSSecretRef2 = {
  /**
   * 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 ImportSourceCertificateUnion2 =
  | ImportSourceCertificateTLSSecretRef2
  | ImportSourceCertificateManagedAcmImport2
  | ImportSourceCertificateAwsAcmArn2
  | ImportSourceCertificateManagedTLSSecret2
  | ImportSourceCertificateNone2;

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

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

export type ImportSourceProviderAzureApplicationGatewayForContainers4 = {
  /**
   * 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: ImportSourceProviderAzureApplicationGatewayForContainersEnum4;
};

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

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

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

export type ImportSourceProviderAwsAlb4 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ImportSourceProviderAwsAlbEnum4;
  /**
   * 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 ImportSourceProviderUnion4 =
  | ImportSourceProviderAwsAlb4
  | ImportSourceProviderAzureApplicationGatewayForContainers4
  | ImportSourceProviderGkeGateway4
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type ImportSourceRouteGateway2 = {
  /**
   * 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?:
    | ImportSourceProviderAwsAlb4
    | ImportSourceProviderAzureApplicationGatewayForContainers4
    | ImportSourceProviderGkeGateway4
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

export type ImportSourceProviderAzureApplicationGatewayForContainers3 = {
  /**
   * 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: ImportSourceProviderAzureApplicationGatewayForContainersEnum3;
};

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

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

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

export type ImportSourceProviderAwsAlb3 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ImportSourceProviderAwsAlbEnum3;
  /**
   * 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 ImportSourceProviderUnion3 =
  | ImportSourceProviderAwsAlb3
  | ImportSourceProviderAzureApplicationGatewayForContainers3
  | ImportSourceProviderGkeGateway3
  | any;

/**
 * Shared Ingress route profile values.
 */
export type ImportSourceRouteIngress2 = {
  /**
   * 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?:
    | ImportSourceProviderAwsAlb3
    | ImportSourceProviderAzureApplicationGatewayForContainers3
    | ImportSourceProviderGkeGateway3
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type ImportSourceRouteUnion2 =
  | ImportSourceRouteIngress2
  | ImportSourceRouteGateway2;

export type ImportSourceExposureCustom = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | ImportSourceCertificateTLSSecretRef2
    | ImportSourceCertificateManagedAcmImport2
    | ImportSourceCertificateAwsAcmArn2
    | ImportSourceCertificateManagedTLSSecret2
    | ImportSourceCertificateNone2;
  /**
   * Hostname routed by the Kubernetes public endpoint.
   */
  domain: string;
  mode: ImportSourceModeCustom;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route: ImportSourceRouteIngress2 | ImportSourceRouteGateway2;
};

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

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

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

export type ImportSourceCertificateManagedAcmImport1 = {
  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 ImportSourceCertificateTLSSecretRef1 = {
  /**
   * 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 ImportSourceCertificateUnion1 =
  | ImportSourceCertificateTLSSecretRef1
  | ImportSourceCertificateManagedAcmImport1
  | ImportSourceCertificateAwsAcmArn1
  | ImportSourceCertificateManagedTLSSecret1
  | ImportSourceCertificateNone1;

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

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

export type ImportSourceProviderAzureApplicationGatewayForContainers2 = {
  /**
   * 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: ImportSourceProviderAzureApplicationGatewayForContainersEnum2;
};

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

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

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

export type ImportSourceProviderAwsAlb2 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ImportSourceProviderAwsAlbEnum2;
  /**
   * 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 ImportSourceProviderUnion2 =
  | ImportSourceProviderAwsAlb2
  | ImportSourceProviderAzureApplicationGatewayForContainers2
  | ImportSourceProviderGkeGateway2
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type ImportSourceRouteGateway1 = {
  /**
   * 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?:
    | ImportSourceProviderAwsAlb2
    | ImportSourceProviderAzureApplicationGatewayForContainers2
    | ImportSourceProviderGkeGateway2
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

export type ImportSourceProviderAzureApplicationGatewayForContainers1 = {
  /**
   * 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: ImportSourceProviderAzureApplicationGatewayForContainersEnum1;
};

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

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

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

export type ImportSourceProviderAwsAlb1 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ImportSourceProviderAwsAlbEnum1;
  /**
   * 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 ImportSourceProviderUnion1 =
  | ImportSourceProviderAwsAlb1
  | ImportSourceProviderAzureApplicationGatewayForContainers1
  | ImportSourceProviderGkeGateway1
  | any;

/**
 * Shared Ingress route profile values.
 */
export type ImportSourceRouteIngress1 = {
  /**
   * 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?:
    | ImportSourceProviderAwsAlb1
    | ImportSourceProviderAzureApplicationGatewayForContainers1
    | ImportSourceProviderGkeGateway1
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type ImportSourceRouteUnion1 =
  | ImportSourceRouteIngress1
  | ImportSourceRouteGateway1;

export type ImportSourceExposureGenerated = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | ImportSourceCertificateTLSSecretRef1
    | ImportSourceCertificateManagedAcmImport1
    | ImportSourceCertificateAwsAcmArn1
    | ImportSourceCertificateManagedTLSSecret1
    | ImportSourceCertificateNone1;
  mode: ImportSourceModeGenerated;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route: ImportSourceRouteIngress1 | ImportSourceRouteGateway1;
};

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

export type ImportSourceExposureDisabled = {
  mode: ImportSourceModeDisabled;
};

export type ImportSourceExposureUnion =
  | ImportSourceExposureCustom
  | ImportSourceExposureGenerated
  | ImportSourceExposureDisabled
  | 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 ImportSourceKubernetes = {
  cluster?: ImportSourceCluster | any | null | undefined;
  exposure?:
    | ImportSourceExposureCustom
    | ImportSourceExposureGenerated
    | ImportSourceExposureDisabled
    | any
    | null
    | undefined;
};

export type ImportSourceKubernetesUnion = ImportSourceKubernetes | any;

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

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

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

export type ImportSourceNetworkByoVpcGcp = {
  /**
   * 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: ImportSourceTypeByoVpcGcp;
};

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

export type ImportSourceNetworkByoVpcAws = {
  /**
   * 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: ImportSourceTypeByoVpcAws;
  /**
   * The ID of the existing VPC
   */
  vpcId: string;
};

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

export type ImportSourceNetworkCreate = {
  /**
   * 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: ImportSourceTypeCreate;
};

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

export type ImportSourceNetworkUseDefault = {
  type: ImportSourceTypeUseDefault;
};

export type ImportSourceNetworkUnion =
  | ImportSourceNetworkByoVpcAws
  | ImportSourceNetworkByoVpcGcp
  | ImportSourceNetworkByoVnetAzure
  | ImportSourceNetworkUseDefault
  | ImportSourceNetworkCreate
  | any;

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

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

/**
 * 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 ImportSourceStackSettings = {
  compute?: ImportSourceCompute | any | null | undefined;
  /**
   * Deployment model: how updates are delivered to the remote environment.
   */
  deploymentModel?: ImportSourceDeploymentModel | undefined;
  domains?: ImportSourceDomains | 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?: ImportSourceExternalBindings | null | undefined;
  /**
   * How heartbeat health checks are handled.
   */
  heartbeats?: ImportSourceHeartbeats | undefined;
  kubernetes?: ImportSourceKubernetes | any | null | undefined;
  network?:
    | ImportSourceNetworkByoVpcAws
    | ImportSourceNetworkByoVpcGcp
    | ImportSourceNetworkByoVnetAzure
    | ImportSourceNetworkUseDefault
    | ImportSourceNetworkCreate
    | 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?: ImportSourceTelemetry | undefined;
  /**
   * How updates are delivered to the deployment.
   */
  updates?: ImportSourceUpdates | undefined;
};

export const ImportSourcePlatformKubernetes = {
  Kubernetes: "kubernetes",
} as const;
export type ImportSourcePlatformKubernetes = ClosedEnum<
  typeof ImportSourcePlatformKubernetes
>;

export type ImportSourceManagementConfigKubernetes = {
  platform: ImportSourcePlatformKubernetes;
};

export const ImportSourcePlatformAzure = {
  Azure: "azure",
} as const;
export type ImportSourcePlatformAzure = ClosedEnum<
  typeof ImportSourcePlatformAzure
>;

/**
 * Azure management configuration extracted from stack settings
 */
export type ImportSourceManagementConfigAzure = {
  /**
   * The managing Azure Tenant ID for cross-tenant access
   */
  managingTenantId: string;
  /**
   * OIDC issuer URL trusted by the target-side managed identity.
   */
  oidcIssuer: string;
  /**
   * OIDC subject claim trusted by the target-side managed identity.
   */
  oidcSubject: string;
  platform: ImportSourcePlatformAzure;
};

export const ImportSourcePlatformGcp = {
  Gcp: "gcp",
} as const;
export type ImportSourcePlatformGcp = ClosedEnum<
  typeof ImportSourcePlatformGcp
>;

/**
 * GCP management configuration extracted from stack settings
 */
export type ImportSourceManagementConfigGcp = {
  /**
   * Service account email for management roles
   */
  serviceAccountEmail: string;
  platform: ImportSourcePlatformGcp;
};

export const ImportSourcePlatformAws = {
  Aws: "aws",
} as const;
export type ImportSourcePlatformAws = ClosedEnum<
  typeof ImportSourcePlatformAws
>;

/**
 * AWS management configuration extracted from stack settings
 */
export type ImportSourceManagementConfigAws = {
  /**
   * The managing AWS IAM role ARN that can assume cross-account roles
   */
  managingRoleArn: string;
  platform: ImportSourcePlatformAws;
};

/**
 * Management configuration for different cloud platforms.
 *
 * @remarks
 *
 * Platform-derived configuration for cross-account/cross-tenant access.
 * This is NOT user-specified - it's derived from the Manager's ServiceAccount.
 */
export type ImportSourceManagementConfigUnion =
  | ImportSourceManagementConfigAzure
  | ImportSourceManagementConfigAws
  | ImportSourceManagementConfigGcp
  | ImportSourceManagementConfigKubernetes
  | any;

/**
 * Resolved setup import payload
 */
export type ImportSource = {
  /**
   * User-chosen deployment name. Must be unique within the deployment group; the manager returns 409 on collision.
   */
  deploymentName: string;
  resourcePrefix: string;
  /**
   * Source label for observability only — does not affect import behavior.
   */
  sourceKind?: ImportSourceKind | undefined;
  setupMetadata?: { [k: string]: any | null } | undefined;
  /**
   * Release that produced the setup artifact. Defaults to latest.
   */
  releaseId?: string | undefined;
  /**
   * Cloud platform of the imported stack
   */
  platform: ImportSourcePlatform;
  /**
   * Base cloud platform for cloud-backed Kubernetes imports.
   */
  basePlatform?: KubernetesBasePlatform | undefined;
  /**
   * Region or location reported by the setup artifact
   */
  region: string;
  setupTarget: string;
  /**
   * Setup import payload format version embedded in the package
   */
  setupImportFormatVersion: number;
  setupFingerprint: string;
  setupFingerprintVersion: number;
  /**
   * 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: ImportSourceStackSettings;
  /**
   * Management configuration for different cloud platforms.
   *
   * @remarks
   *
   * Platform-derived configuration for cross-account/cross-tenant access.
   * This is NOT user-specified - it's derived from the Manager's ServiceAccount.
   */
  managementConfig?:
    | ImportSourceManagementConfigAzure
    | ImportSourceManagementConfigAws
    | ImportSourceManagementConfigGcp
    | ImportSourceManagementConfigKubernetes
    | any
    | null
    | undefined;
  resources: Array<ImportedResource>;
};

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

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

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

export function importSourceFailureDomains2ToJSON(
  importSourceFailureDomains2: ImportSourceFailureDomains2,
): string {
  return JSON.stringify(
    ImportSourceFailureDomains2$outboundSchema.parse(
      importSourceFailureDomains2,
    ),
  );
}

/** @internal */
export type ImportSourceFailureDomainsUnion2$Outbound =
  | ImportSourceFailureDomains2$Outbound
  | any;

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

export function importSourceFailureDomainsUnion2ToJSON(
  importSourceFailureDomainsUnion2: ImportSourceFailureDomainsUnion2,
): string {
  return JSON.stringify(
    ImportSourceFailureDomainsUnion2$outboundSchema.parse(
      importSourceFailureDomainsUnion2,
    ),
  );
}

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

/** @internal */
export const ImportSourcePoolsAutoscale$outboundSchema: z.ZodType<
  ImportSourcePoolsAutoscale$Outbound,
  ImportSourcePoolsAutoscale
> = z.object({
  failureDomains: z.nullable(
    z.union([
      z.lazy(() => ImportSourceFailureDomains2$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 importSourcePoolsAutoscaleToJSON(
  importSourcePoolsAutoscale: ImportSourcePoolsAutoscale,
): string {
  return JSON.stringify(
    ImportSourcePoolsAutoscale$outboundSchema.parse(importSourcePoolsAutoscale),
  );
}

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

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

export function importSourceFailureDomains1ToJSON(
  importSourceFailureDomains1: ImportSourceFailureDomains1,
): string {
  return JSON.stringify(
    ImportSourceFailureDomains1$outboundSchema.parse(
      importSourceFailureDomains1,
    ),
  );
}

/** @internal */
export type ImportSourceFailureDomainsUnion1$Outbound =
  | ImportSourceFailureDomains1$Outbound
  | any;

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

export function importSourceFailureDomainsUnion1ToJSON(
  importSourceFailureDomainsUnion1: ImportSourceFailureDomainsUnion1,
): string {
  return JSON.stringify(
    ImportSourceFailureDomainsUnion1$outboundSchema.parse(
      importSourceFailureDomainsUnion1,
    ),
  );
}

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

/** @internal */
export const ImportSourcePoolsFixed$outboundSchema: z.ZodType<
  ImportSourcePoolsFixed$Outbound,
  ImportSourcePoolsFixed
> = z.object({
  failureDomains: z.nullable(
    z.union([
      z.lazy(() => ImportSourceFailureDomains1$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 importSourcePoolsFixedToJSON(
  importSourcePoolsFixed: ImportSourcePoolsFixed,
): string {
  return JSON.stringify(
    ImportSourcePoolsFixed$outboundSchema.parse(importSourcePoolsFixed),
  );
}

/** @internal */
export type ImportSourcePoolsUnion$Outbound =
  | ImportSourcePoolsFixed$Outbound
  | ImportSourcePoolsAutoscale$Outbound;

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

export function importSourcePoolsUnionToJSON(
  importSourcePoolsUnion: ImportSourcePoolsUnion,
): string {
  return JSON.stringify(
    ImportSourcePoolsUnion$outboundSchema.parse(importSourcePoolsUnion),
  );
}

/** @internal */
export type ImportSourceCompute$Outbound = {
  pools?: {
    [k: string]:
      | ImportSourcePoolsFixed$Outbound
      | ImportSourcePoolsAutoscale$Outbound;
  } | undefined;
};

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

export function importSourceComputeToJSON(
  importSourceCompute: ImportSourceCompute,
): string {
  return JSON.stringify(
    ImportSourceCompute$outboundSchema.parse(importSourceCompute),
  );
}

/** @internal */
export type ImportSourceComputeUnion$Outbound =
  | ImportSourceCompute$Outbound
  | any;

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

export function importSourceComputeUnionToJSON(
  importSourceComputeUnion: ImportSourceComputeUnion,
): string {
  return JSON.stringify(
    ImportSourceComputeUnion$outboundSchema.parse(importSourceComputeUnion),
  );
}

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

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

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

export function importSourceAwsToJSON(
  importSourceAws: ImportSourceAws,
): string {
  return JSON.stringify(ImportSourceAws$outboundSchema.parse(importSourceAws));
}

/** @internal */
export type ImportSourceAwsUnion$Outbound = ImportSourceAws$Outbound | any;

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

export function importSourceAwsUnionToJSON(
  importSourceAwsUnion: ImportSourceAwsUnion,
): string {
  return JSON.stringify(
    ImportSourceAwsUnion$outboundSchema.parse(importSourceAwsUnion),
  );
}

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

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

export function importSourceAzureToJSON(
  importSourceAzure: ImportSourceAzure,
): string {
  return JSON.stringify(
    ImportSourceAzure$outboundSchema.parse(importSourceAzure),
  );
}

/** @internal */
export type ImportSourceAzureUnion$Outbound = ImportSourceAzure$Outbound | any;

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

export function importSourceAzureUnionToJSON(
  importSourceAzureUnion: ImportSourceAzureUnion,
): string {
  return JSON.stringify(
    ImportSourceAzureUnion$outboundSchema.parse(importSourceAzureUnion),
  );
}

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

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

export function importSourceGcpToJSON(
  importSourceGcp: ImportSourceGcp,
): string {
  return JSON.stringify(ImportSourceGcp$outboundSchema.parse(importSourceGcp));
}

/** @internal */
export type ImportSourceGcpUnion$Outbound = ImportSourceGcp$Outbound | any;

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

export function importSourceGcpUnionToJSON(
  importSourceGcpUnion: ImportSourceGcpUnion,
): string {
  return JSON.stringify(
    ImportSourceGcpUnion$outboundSchema.parse(importSourceGcpUnion),
  );
}

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

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

export function importSourceTlsSecretRefToJSON(
  importSourceTlsSecretRef: ImportSourceTlsSecretRef,
): string {
  return JSON.stringify(
    ImportSourceTlsSecretRef$outboundSchema.parse(importSourceTlsSecretRef),
  );
}

/** @internal */
export type ImportSourceDomainsKubernetes$Outbound = {
  tlsSecretRef: ImportSourceTlsSecretRef$Outbound;
};

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

export function importSourceDomainsKubernetesToJSON(
  importSourceDomainsKubernetes: ImportSourceDomainsKubernetes,
): string {
  return JSON.stringify(
    ImportSourceDomainsKubernetes$outboundSchema.parse(
      importSourceDomainsKubernetes,
    ),
  );
}

/** @internal */
export type ImportSourceDomainsKubernetesUnion$Outbound =
  | ImportSourceDomainsKubernetes$Outbound
  | any;

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

export function importSourceDomainsKubernetesUnionToJSON(
  importSourceDomainsKubernetesUnion: ImportSourceDomainsKubernetesUnion,
): string {
  return JSON.stringify(
    ImportSourceDomainsKubernetesUnion$outboundSchema.parse(
      importSourceDomainsKubernetesUnion,
    ),
  );
}

/** @internal */
export type ImportSourceDomainsCertificate$Outbound = {
  aws?: ImportSourceAws$Outbound | any | null | undefined;
  azure?: ImportSourceAzure$Outbound | any | null | undefined;
  gcp?: ImportSourceGcp$Outbound | any | null | undefined;
  kubernetes?: ImportSourceDomainsKubernetes$Outbound | any | null | undefined;
};

/** @internal */
export const ImportSourceDomainsCertificate$outboundSchema: z.ZodType<
  ImportSourceDomainsCertificate$Outbound,
  ImportSourceDomainsCertificate
> = z.object({
  aws: z.nullable(
    z.union([z.lazy(() => ImportSourceAws$outboundSchema), z.any()]),
  ).optional(),
  azure: z.nullable(
    z.union([z.lazy(() => ImportSourceAzure$outboundSchema), z.any()]),
  ).optional(),
  gcp: z.nullable(
    z.union([z.lazy(() => ImportSourceGcp$outboundSchema), z.any()]),
  ).optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => ImportSourceDomainsKubernetes$outboundSchema),
      z.any(),
    ]),
  ).optional(),
});

export function importSourceDomainsCertificateToJSON(
  importSourceDomainsCertificate: ImportSourceDomainsCertificate,
): string {
  return JSON.stringify(
    ImportSourceDomainsCertificate$outboundSchema.parse(
      importSourceDomainsCertificate,
    ),
  );
}

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

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

export function importSourceCustomDomainsToJSON(
  importSourceCustomDomains: ImportSourceCustomDomains,
): string {
  return JSON.stringify(
    ImportSourceCustomDomains$outboundSchema.parse(importSourceCustomDomains),
  );
}

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

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

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

export function importSourcePublicEndpointTargetLoadBalancerToJSON(
  importSourcePublicEndpointTargetLoadBalancer:
    ImportSourcePublicEndpointTargetLoadBalancer,
): string {
  return JSON.stringify(
    ImportSourcePublicEndpointTargetLoadBalancer$outboundSchema.parse(
      importSourcePublicEndpointTargetLoadBalancer,
    ),
  );
}

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

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

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

export function importSourcePublicEndpointTargetMachineAddressesToJSON(
  importSourcePublicEndpointTargetMachineAddresses:
    ImportSourcePublicEndpointTargetMachineAddresses,
): string {
  return JSON.stringify(
    ImportSourcePublicEndpointTargetMachineAddresses$outboundSchema.parse(
      importSourcePublicEndpointTargetMachineAddresses,
    ),
  );
}

/** @internal */
export type ImportSourcePublicEndpointTargetUnion$Outbound =
  | ImportSourcePublicEndpointTargetLoadBalancer$Outbound
  | ImportSourcePublicEndpointTargetMachineAddresses$Outbound
  | any;

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

export function importSourcePublicEndpointTargetUnionToJSON(
  importSourcePublicEndpointTargetUnion: ImportSourcePublicEndpointTargetUnion,
): string {
  return JSON.stringify(
    ImportSourcePublicEndpointTargetUnion$outboundSchema.parse(
      importSourcePublicEndpointTargetUnion,
    ),
  );
}

/** @internal */
export type ImportSourceDomains$Outbound = {
  customDomains?:
    | { [k: string]: ImportSourceCustomDomains$Outbound }
    | null
    | undefined;
  publicEndpointTarget?:
    | ImportSourcePublicEndpointTargetLoadBalancer$Outbound
    | ImportSourcePublicEndpointTargetMachineAddresses$Outbound
    | any
    | null
    | undefined;
};

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

export function importSourceDomainsToJSON(
  importSourceDomains: ImportSourceDomains,
): string {
  return JSON.stringify(
    ImportSourceDomains$outboundSchema.parse(importSourceDomains),
  );
}

/** @internal */
export type ImportSourceDomainsUnion$Outbound =
  | ImportSourceDomains$Outbound
  | any;

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

export function importSourceDomainsUnionToJSON(
  importSourceDomainsUnion: ImportSourceDomainsUnion,
): string {
  return JSON.stringify(
    ImportSourceDomainsUnion$outboundSchema.parse(importSourceDomainsUnion),
  );
}

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

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

export function importSourceExternalBindingsToJSON(
  importSourceExternalBindings: ImportSourceExternalBindings,
): string {
  return JSON.stringify(
    ImportSourceExternalBindings$outboundSchema.parse(
      importSourceExternalBindings,
    ),
  );
}

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

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

/** @internal */
export type ImportSourceCloudUnion$Outbound = ImportSourceCloud$Outbound | any;

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

export function importSourceCloudUnionToJSON(
  importSourceCloudUnion: ImportSourceCloudUnion,
): string {
  return JSON.stringify(
    ImportSourceCloudUnion$outboundSchema.parse(importSourceCloudUnion),
  );
}

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

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

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

export function importSourceClusterToJSON(
  importSourceCluster: ImportSourceCluster,
): string {
  return JSON.stringify(
    ImportSourceCluster$outboundSchema.parse(importSourceCluster),
  );
}

/** @internal */
export type ImportSourceClusterUnion$Outbound =
  | ImportSourceCluster$Outbound
  | any;

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

export function importSourceClusterUnionToJSON(
  importSourceClusterUnion: ImportSourceClusterUnion,
): string {
  return JSON.stringify(
    ImportSourceClusterUnion$outboundSchema.parse(importSourceClusterUnion),
  );
}

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

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

export function importSourceCertificateNone2ToJSON(
  importSourceCertificateNone2: ImportSourceCertificateNone2,
): string {
  return JSON.stringify(
    ImportSourceCertificateNone2$outboundSchema.parse(
      importSourceCertificateNone2,
    ),
  );
}

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

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

export function importSourceCertificateManagedTLSSecret2ToJSON(
  importSourceCertificateManagedTLSSecret2:
    ImportSourceCertificateManagedTLSSecret2,
): string {
  return JSON.stringify(
    ImportSourceCertificateManagedTLSSecret2$outboundSchema.parse(
      importSourceCertificateManagedTLSSecret2,
    ),
  );
}

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

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

export function importSourceCertificateAwsAcmArn2ToJSON(
  importSourceCertificateAwsAcmArn2: ImportSourceCertificateAwsAcmArn2,
): string {
  return JSON.stringify(
    ImportSourceCertificateAwsAcmArn2$outboundSchema.parse(
      importSourceCertificateAwsAcmArn2,
    ),
  );
}

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

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

export function importSourceCertificateManagedAcmImport2ToJSON(
  importSourceCertificateManagedAcmImport2:
    ImportSourceCertificateManagedAcmImport2,
): string {
  return JSON.stringify(
    ImportSourceCertificateManagedAcmImport2$outboundSchema.parse(
      importSourceCertificateManagedAcmImport2,
    ),
  );
}

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

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

export function importSourceCertificateTLSSecretRef2ToJSON(
  importSourceCertificateTLSSecretRef2: ImportSourceCertificateTLSSecretRef2,
): string {
  return JSON.stringify(
    ImportSourceCertificateTLSSecretRef2$outboundSchema.parse(
      importSourceCertificateTLSSecretRef2,
    ),
  );
}

/** @internal */
export type ImportSourceCertificateUnion2$Outbound =
  | ImportSourceCertificateTLSSecretRef2$Outbound
  | ImportSourceCertificateManagedAcmImport2$Outbound
  | ImportSourceCertificateAwsAcmArn2$Outbound
  | ImportSourceCertificateManagedTLSSecret2$Outbound
  | ImportSourceCertificateNone2$Outbound;

/** @internal */
export const ImportSourceCertificateUnion2$outboundSchema: z.ZodType<
  ImportSourceCertificateUnion2$Outbound,
  ImportSourceCertificateUnion2
> = z.union([
  z.lazy(() => ImportSourceCertificateTLSSecretRef2$outboundSchema),
  z.lazy(() => ImportSourceCertificateManagedAcmImport2$outboundSchema),
  z.lazy(() => ImportSourceCertificateAwsAcmArn2$outboundSchema),
  z.lazy(() => ImportSourceCertificateManagedTLSSecret2$outboundSchema),
  z.lazy(() => ImportSourceCertificateNone2$outboundSchema),
]);

export function importSourceCertificateUnion2ToJSON(
  importSourceCertificateUnion2: ImportSourceCertificateUnion2,
): string {
  return JSON.stringify(
    ImportSourceCertificateUnion2$outboundSchema.parse(
      importSourceCertificateUnion2,
    ),
  );
}

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

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

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

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

export function importSourceProviderAzureApplicationGatewayForContainers4ToJSON(
  importSourceProviderAzureApplicationGatewayForContainers4:
    ImportSourceProviderAzureApplicationGatewayForContainers4,
): string {
  return JSON.stringify(
    ImportSourceProviderAzureApplicationGatewayForContainers4$outboundSchema
      .parse(importSourceProviderAzureApplicationGatewayForContainers4),
  );
}

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

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

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

export function importSourceProviderGkeGateway4ToJSON(
  importSourceProviderGkeGateway4: ImportSourceProviderGkeGateway4,
): string {
  return JSON.stringify(
    ImportSourceProviderGkeGateway4$outboundSchema.parse(
      importSourceProviderGkeGateway4,
    ),
  );
}

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

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

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

export function importSourceProviderAwsAlb4ToJSON(
  importSourceProviderAwsAlb4: ImportSourceProviderAwsAlb4,
): string {
  return JSON.stringify(
    ImportSourceProviderAwsAlb4$outboundSchema.parse(
      importSourceProviderAwsAlb4,
    ),
  );
}

/** @internal */
export type ImportSourceProviderUnion4$Outbound =
  | ImportSourceProviderAwsAlb4$Outbound
  | ImportSourceProviderAzureApplicationGatewayForContainers4$Outbound
  | ImportSourceProviderGkeGateway4$Outbound
  | any;

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

export function importSourceProviderUnion4ToJSON(
  importSourceProviderUnion4: ImportSourceProviderUnion4,
): string {
  return JSON.stringify(
    ImportSourceProviderUnion4$outboundSchema.parse(importSourceProviderUnion4),
  );
}

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

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

export function importSourceRouteGateway2ToJSON(
  importSourceRouteGateway2: ImportSourceRouteGateway2,
): string {
  return JSON.stringify(
    ImportSourceRouteGateway2$outboundSchema.parse(importSourceRouteGateway2),
  );
}

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

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

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

export function importSourceProviderAzureApplicationGatewayForContainers3ToJSON(
  importSourceProviderAzureApplicationGatewayForContainers3:
    ImportSourceProviderAzureApplicationGatewayForContainers3,
): string {
  return JSON.stringify(
    ImportSourceProviderAzureApplicationGatewayForContainers3$outboundSchema
      .parse(importSourceProviderAzureApplicationGatewayForContainers3),
  );
}

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

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

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

export function importSourceProviderGkeGateway3ToJSON(
  importSourceProviderGkeGateway3: ImportSourceProviderGkeGateway3,
): string {
  return JSON.stringify(
    ImportSourceProviderGkeGateway3$outboundSchema.parse(
      importSourceProviderGkeGateway3,
    ),
  );
}

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

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

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

export function importSourceProviderAwsAlb3ToJSON(
  importSourceProviderAwsAlb3: ImportSourceProviderAwsAlb3,
): string {
  return JSON.stringify(
    ImportSourceProviderAwsAlb3$outboundSchema.parse(
      importSourceProviderAwsAlb3,
    ),
  );
}

/** @internal */
export type ImportSourceProviderUnion3$Outbound =
  | ImportSourceProviderAwsAlb3$Outbound
  | ImportSourceProviderAzureApplicationGatewayForContainers3$Outbound
  | ImportSourceProviderGkeGateway3$Outbound
  | any;

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

export function importSourceProviderUnion3ToJSON(
  importSourceProviderUnion3: ImportSourceProviderUnion3,
): string {
  return JSON.stringify(
    ImportSourceProviderUnion3$outboundSchema.parse(importSourceProviderUnion3),
  );
}

/** @internal */
export type ImportSourceRouteIngress2$Outbound = {
  annotations?: { [k: string]: string } | undefined;
  controller?: string | null | undefined;
  ingressClassName: string;
  labels?: { [k: string]: string } | undefined;
  provider?:
    | ImportSourceProviderAwsAlb3$Outbound
    | ImportSourceProviderAzureApplicationGatewayForContainers3$Outbound
    | ImportSourceProviderGkeGateway3$Outbound
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

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

export function importSourceRouteIngress2ToJSON(
  importSourceRouteIngress2: ImportSourceRouteIngress2,
): string {
  return JSON.stringify(
    ImportSourceRouteIngress2$outboundSchema.parse(importSourceRouteIngress2),
  );
}

/** @internal */
export type ImportSourceRouteUnion2$Outbound =
  | ImportSourceRouteIngress2$Outbound
  | ImportSourceRouteGateway2$Outbound;

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

export function importSourceRouteUnion2ToJSON(
  importSourceRouteUnion2: ImportSourceRouteUnion2,
): string {
  return JSON.stringify(
    ImportSourceRouteUnion2$outboundSchema.parse(importSourceRouteUnion2),
  );
}

/** @internal */
export type ImportSourceExposureCustom$Outbound = {
  certificate:
    | ImportSourceCertificateTLSSecretRef2$Outbound
    | ImportSourceCertificateManagedAcmImport2$Outbound
    | ImportSourceCertificateAwsAcmArn2$Outbound
    | ImportSourceCertificateManagedTLSSecret2$Outbound
    | ImportSourceCertificateNone2$Outbound;
  domain: string;
  mode: string;
  route:
    | ImportSourceRouteIngress2$Outbound
    | ImportSourceRouteGateway2$Outbound;
};

/** @internal */
export const ImportSourceExposureCustom$outboundSchema: z.ZodType<
  ImportSourceExposureCustom$Outbound,
  ImportSourceExposureCustom
> = z.object({
  certificate: z.union([
    z.lazy(() => ImportSourceCertificateTLSSecretRef2$outboundSchema),
    z.lazy(() => ImportSourceCertificateManagedAcmImport2$outboundSchema),
    z.lazy(() => ImportSourceCertificateAwsAcmArn2$outboundSchema),
    z.lazy(() => ImportSourceCertificateManagedTLSSecret2$outboundSchema),
    z.lazy(() => ImportSourceCertificateNone2$outboundSchema),
  ]),
  domain: z.string(),
  mode: ImportSourceModeCustom$outboundSchema,
  route: z.union([
    z.lazy(() => ImportSourceRouteIngress2$outboundSchema),
    z.lazy(() => ImportSourceRouteGateway2$outboundSchema),
  ]),
});

export function importSourceExposureCustomToJSON(
  importSourceExposureCustom: ImportSourceExposureCustom,
): string {
  return JSON.stringify(
    ImportSourceExposureCustom$outboundSchema.parse(importSourceExposureCustom),
  );
}

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

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

export function importSourceCertificateNone1ToJSON(
  importSourceCertificateNone1: ImportSourceCertificateNone1,
): string {
  return JSON.stringify(
    ImportSourceCertificateNone1$outboundSchema.parse(
      importSourceCertificateNone1,
    ),
  );
}

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

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

export function importSourceCertificateManagedTLSSecret1ToJSON(
  importSourceCertificateManagedTLSSecret1:
    ImportSourceCertificateManagedTLSSecret1,
): string {
  return JSON.stringify(
    ImportSourceCertificateManagedTLSSecret1$outboundSchema.parse(
      importSourceCertificateManagedTLSSecret1,
    ),
  );
}

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

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

export function importSourceCertificateAwsAcmArn1ToJSON(
  importSourceCertificateAwsAcmArn1: ImportSourceCertificateAwsAcmArn1,
): string {
  return JSON.stringify(
    ImportSourceCertificateAwsAcmArn1$outboundSchema.parse(
      importSourceCertificateAwsAcmArn1,
    ),
  );
}

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

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

export function importSourceCertificateManagedAcmImport1ToJSON(
  importSourceCertificateManagedAcmImport1:
    ImportSourceCertificateManagedAcmImport1,
): string {
  return JSON.stringify(
    ImportSourceCertificateManagedAcmImport1$outboundSchema.parse(
      importSourceCertificateManagedAcmImport1,
    ),
  );
}

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

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

export function importSourceCertificateTLSSecretRef1ToJSON(
  importSourceCertificateTLSSecretRef1: ImportSourceCertificateTLSSecretRef1,
): string {
  return JSON.stringify(
    ImportSourceCertificateTLSSecretRef1$outboundSchema.parse(
      importSourceCertificateTLSSecretRef1,
    ),
  );
}

/** @internal */
export type ImportSourceCertificateUnion1$Outbound =
  | ImportSourceCertificateTLSSecretRef1$Outbound
  | ImportSourceCertificateManagedAcmImport1$Outbound
  | ImportSourceCertificateAwsAcmArn1$Outbound
  | ImportSourceCertificateManagedTLSSecret1$Outbound
  | ImportSourceCertificateNone1$Outbound;

/** @internal */
export const ImportSourceCertificateUnion1$outboundSchema: z.ZodType<
  ImportSourceCertificateUnion1$Outbound,
  ImportSourceCertificateUnion1
> = z.union([
  z.lazy(() => ImportSourceCertificateTLSSecretRef1$outboundSchema),
  z.lazy(() => ImportSourceCertificateManagedAcmImport1$outboundSchema),
  z.lazy(() => ImportSourceCertificateAwsAcmArn1$outboundSchema),
  z.lazy(() => ImportSourceCertificateManagedTLSSecret1$outboundSchema),
  z.lazy(() => ImportSourceCertificateNone1$outboundSchema),
]);

export function importSourceCertificateUnion1ToJSON(
  importSourceCertificateUnion1: ImportSourceCertificateUnion1,
): string {
  return JSON.stringify(
    ImportSourceCertificateUnion1$outboundSchema.parse(
      importSourceCertificateUnion1,
    ),
  );
}

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

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

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

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

export function importSourceProviderAzureApplicationGatewayForContainers2ToJSON(
  importSourceProviderAzureApplicationGatewayForContainers2:
    ImportSourceProviderAzureApplicationGatewayForContainers2,
): string {
  return JSON.stringify(
    ImportSourceProviderAzureApplicationGatewayForContainers2$outboundSchema
      .parse(importSourceProviderAzureApplicationGatewayForContainers2),
  );
}

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

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

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

export function importSourceProviderGkeGateway2ToJSON(
  importSourceProviderGkeGateway2: ImportSourceProviderGkeGateway2,
): string {
  return JSON.stringify(
    ImportSourceProviderGkeGateway2$outboundSchema.parse(
      importSourceProviderGkeGateway2,
    ),
  );
}

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

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

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

export function importSourceProviderAwsAlb2ToJSON(
  importSourceProviderAwsAlb2: ImportSourceProviderAwsAlb2,
): string {
  return JSON.stringify(
    ImportSourceProviderAwsAlb2$outboundSchema.parse(
      importSourceProviderAwsAlb2,
    ),
  );
}

/** @internal */
export type ImportSourceProviderUnion2$Outbound =
  | ImportSourceProviderAwsAlb2$Outbound
  | ImportSourceProviderAzureApplicationGatewayForContainers2$Outbound
  | ImportSourceProviderGkeGateway2$Outbound
  | any;

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

export function importSourceProviderUnion2ToJSON(
  importSourceProviderUnion2: ImportSourceProviderUnion2,
): string {
  return JSON.stringify(
    ImportSourceProviderUnion2$outboundSchema.parse(importSourceProviderUnion2),
  );
}

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

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

export function importSourceRouteGateway1ToJSON(
  importSourceRouteGateway1: ImportSourceRouteGateway1,
): string {
  return JSON.stringify(
    ImportSourceRouteGateway1$outboundSchema.parse(importSourceRouteGateway1),
  );
}

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

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

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

export function importSourceProviderAzureApplicationGatewayForContainers1ToJSON(
  importSourceProviderAzureApplicationGatewayForContainers1:
    ImportSourceProviderAzureApplicationGatewayForContainers1,
): string {
  return JSON.stringify(
    ImportSourceProviderAzureApplicationGatewayForContainers1$outboundSchema
      .parse(importSourceProviderAzureApplicationGatewayForContainers1),
  );
}

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

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

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

export function importSourceProviderGkeGateway1ToJSON(
  importSourceProviderGkeGateway1: ImportSourceProviderGkeGateway1,
): string {
  return JSON.stringify(
    ImportSourceProviderGkeGateway1$outboundSchema.parse(
      importSourceProviderGkeGateway1,
    ),
  );
}

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

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

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

export function importSourceProviderAwsAlb1ToJSON(
  importSourceProviderAwsAlb1: ImportSourceProviderAwsAlb1,
): string {
  return JSON.stringify(
    ImportSourceProviderAwsAlb1$outboundSchema.parse(
      importSourceProviderAwsAlb1,
    ),
  );
}

/** @internal */
export type ImportSourceProviderUnion1$Outbound =
  | ImportSourceProviderAwsAlb1$Outbound
  | ImportSourceProviderAzureApplicationGatewayForContainers1$Outbound
  | ImportSourceProviderGkeGateway1$Outbound
  | any;

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

export function importSourceProviderUnion1ToJSON(
  importSourceProviderUnion1: ImportSourceProviderUnion1,
): string {
  return JSON.stringify(
    ImportSourceProviderUnion1$outboundSchema.parse(importSourceProviderUnion1),
  );
}

/** @internal */
export type ImportSourceRouteIngress1$Outbound = {
  annotations?: { [k: string]: string } | undefined;
  controller?: string | null | undefined;
  ingressClassName: string;
  labels?: { [k: string]: string } | undefined;
  provider?:
    | ImportSourceProviderAwsAlb1$Outbound
    | ImportSourceProviderAzureApplicationGatewayForContainers1$Outbound
    | ImportSourceProviderGkeGateway1$Outbound
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

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

export function importSourceRouteIngress1ToJSON(
  importSourceRouteIngress1: ImportSourceRouteIngress1,
): string {
  return JSON.stringify(
    ImportSourceRouteIngress1$outboundSchema.parse(importSourceRouteIngress1),
  );
}

/** @internal */
export type ImportSourceRouteUnion1$Outbound =
  | ImportSourceRouteIngress1$Outbound
  | ImportSourceRouteGateway1$Outbound;

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

export function importSourceRouteUnion1ToJSON(
  importSourceRouteUnion1: ImportSourceRouteUnion1,
): string {
  return JSON.stringify(
    ImportSourceRouteUnion1$outboundSchema.parse(importSourceRouteUnion1),
  );
}

/** @internal */
export type ImportSourceExposureGenerated$Outbound = {
  certificate:
    | ImportSourceCertificateTLSSecretRef1$Outbound
    | ImportSourceCertificateManagedAcmImport1$Outbound
    | ImportSourceCertificateAwsAcmArn1$Outbound
    | ImportSourceCertificateManagedTLSSecret1$Outbound
    | ImportSourceCertificateNone1$Outbound;
  mode: string;
  route:
    | ImportSourceRouteIngress1$Outbound
    | ImportSourceRouteGateway1$Outbound;
};

/** @internal */
export const ImportSourceExposureGenerated$outboundSchema: z.ZodType<
  ImportSourceExposureGenerated$Outbound,
  ImportSourceExposureGenerated
> = z.object({
  certificate: z.union([
    z.lazy(() => ImportSourceCertificateTLSSecretRef1$outboundSchema),
    z.lazy(() => ImportSourceCertificateManagedAcmImport1$outboundSchema),
    z.lazy(() => ImportSourceCertificateAwsAcmArn1$outboundSchema),
    z.lazy(() => ImportSourceCertificateManagedTLSSecret1$outboundSchema),
    z.lazy(() => ImportSourceCertificateNone1$outboundSchema),
  ]),
  mode: ImportSourceModeGenerated$outboundSchema,
  route: z.union([
    z.lazy(() => ImportSourceRouteIngress1$outboundSchema),
    z.lazy(() => ImportSourceRouteGateway1$outboundSchema),
  ]),
});

export function importSourceExposureGeneratedToJSON(
  importSourceExposureGenerated: ImportSourceExposureGenerated,
): string {
  return JSON.stringify(
    ImportSourceExposureGenerated$outboundSchema.parse(
      importSourceExposureGenerated,
    ),
  );
}

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

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

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

export function importSourceExposureDisabledToJSON(
  importSourceExposureDisabled: ImportSourceExposureDisabled,
): string {
  return JSON.stringify(
    ImportSourceExposureDisabled$outboundSchema.parse(
      importSourceExposureDisabled,
    ),
  );
}

/** @internal */
export type ImportSourceExposureUnion$Outbound =
  | ImportSourceExposureCustom$Outbound
  | ImportSourceExposureGenerated$Outbound
  | ImportSourceExposureDisabled$Outbound
  | any;

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

export function importSourceExposureUnionToJSON(
  importSourceExposureUnion: ImportSourceExposureUnion,
): string {
  return JSON.stringify(
    ImportSourceExposureUnion$outboundSchema.parse(importSourceExposureUnion),
  );
}

/** @internal */
export type ImportSourceKubernetes$Outbound = {
  cluster?: ImportSourceCluster$Outbound | any | null | undefined;
  exposure?:
    | ImportSourceExposureCustom$Outbound
    | ImportSourceExposureGenerated$Outbound
    | ImportSourceExposureDisabled$Outbound
    | any
    | null
    | undefined;
};

/** @internal */
export const ImportSourceKubernetes$outboundSchema: z.ZodType<
  ImportSourceKubernetes$Outbound,
  ImportSourceKubernetes
> = z.object({
  cluster: z.nullable(
    z.union([z.lazy(() => ImportSourceCluster$outboundSchema), z.any()]),
  ).optional(),
  exposure: z.nullable(
    z.union([
      z.lazy(() => ImportSourceExposureCustom$outboundSchema),
      z.lazy(() => ImportSourceExposureGenerated$outboundSchema),
      z.lazy(() => ImportSourceExposureDisabled$outboundSchema),
      z.any(),
    ]),
  ).optional(),
});

export function importSourceKubernetesToJSON(
  importSourceKubernetes: ImportSourceKubernetes,
): string {
  return JSON.stringify(
    ImportSourceKubernetes$outboundSchema.parse(importSourceKubernetes),
  );
}

/** @internal */
export type ImportSourceKubernetesUnion$Outbound =
  | ImportSourceKubernetes$Outbound
  | any;

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

export function importSourceKubernetesUnionToJSON(
  importSourceKubernetesUnion: ImportSourceKubernetesUnion,
): string {
  return JSON.stringify(
    ImportSourceKubernetesUnion$outboundSchema.parse(
      importSourceKubernetesUnion,
    ),
  );
}

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

/** @internal */
export type ImportSourceNetworkByoVnetAzure$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 ImportSourceNetworkByoVnetAzure$outboundSchema: z.ZodType<
  ImportSourceNetworkByoVnetAzure$Outbound,
  ImportSourceNetworkByoVnetAzure
> = z.object({
  applicationGatewaySubnetName: z.nullable(z.string()).optional(),
  privateEndpointSubnetName: z.nullable(z.string()).optional(),
  privateSubnetName: z.string(),
  publicSubnetName: z.string(),
  type: ImportSourceTypeByoVnetAzure$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 importSourceNetworkByoVnetAzureToJSON(
  importSourceNetworkByoVnetAzure: ImportSourceNetworkByoVnetAzure,
): string {
  return JSON.stringify(
    ImportSourceNetworkByoVnetAzure$outboundSchema.parse(
      importSourceNetworkByoVnetAzure,
    ),
  );
}

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

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

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

export function importSourceNetworkByoVpcGcpToJSON(
  importSourceNetworkByoVpcGcp: ImportSourceNetworkByoVpcGcp,
): string {
  return JSON.stringify(
    ImportSourceNetworkByoVpcGcp$outboundSchema.parse(
      importSourceNetworkByoVpcGcp,
    ),
  );
}

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

/** @internal */
export type ImportSourceNetworkByoVpcAws$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 ImportSourceNetworkByoVpcAws$outboundSchema: z.ZodType<
  ImportSourceNetworkByoVpcAws$Outbound,
  ImportSourceNetworkByoVpcAws
> = z.object({
  privateSubnetIds: z.array(z.string()),
  publicSubnetIds: z.array(z.string()),
  securityGroupIds: z.array(z.string()).optional(),
  type: ImportSourceTypeByoVpcAws$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 importSourceNetworkByoVpcAwsToJSON(
  importSourceNetworkByoVpcAws: ImportSourceNetworkByoVpcAws,
): string {
  return JSON.stringify(
    ImportSourceNetworkByoVpcAws$outboundSchema.parse(
      importSourceNetworkByoVpcAws,
    ),
  );
}

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

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

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

export function importSourceNetworkCreateToJSON(
  importSourceNetworkCreate: ImportSourceNetworkCreate,
): string {
  return JSON.stringify(
    ImportSourceNetworkCreate$outboundSchema.parse(importSourceNetworkCreate),
  );
}

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

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

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

export function importSourceNetworkUseDefaultToJSON(
  importSourceNetworkUseDefault: ImportSourceNetworkUseDefault,
): string {
  return JSON.stringify(
    ImportSourceNetworkUseDefault$outboundSchema.parse(
      importSourceNetworkUseDefault,
    ),
  );
}

/** @internal */
export type ImportSourceNetworkUnion$Outbound =
  | ImportSourceNetworkByoVpcAws$Outbound
  | ImportSourceNetworkByoVpcGcp$Outbound
  | ImportSourceNetworkByoVnetAzure$Outbound
  | ImportSourceNetworkUseDefault$Outbound
  | ImportSourceNetworkCreate$Outbound
  | any;

/** @internal */
export const ImportSourceNetworkUnion$outboundSchema: z.ZodType<
  ImportSourceNetworkUnion$Outbound,
  ImportSourceNetworkUnion
> = z.union([
  z.lazy(() => ImportSourceNetworkByoVpcAws$outboundSchema),
  z.lazy(() => ImportSourceNetworkByoVpcGcp$outboundSchema),
  z.lazy(() => ImportSourceNetworkByoVnetAzure$outboundSchema),
  z.lazy(() => ImportSourceNetworkUseDefault$outboundSchema),
  z.lazy(() => ImportSourceNetworkCreate$outboundSchema),
  z.any(),
]);

export function importSourceNetworkUnionToJSON(
  importSourceNetworkUnion: ImportSourceNetworkUnion,
): string {
  return JSON.stringify(
    ImportSourceNetworkUnion$outboundSchema.parse(importSourceNetworkUnion),
  );
}

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

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

/** @internal */
export type ImportSourceStackSettings$Outbound = {
  compute?: ImportSourceCompute$Outbound | any | null | undefined;
  deploymentModel?: string | undefined;
  domains?: ImportSourceDomains$Outbound | any | null | undefined;
  externalBindings?: ImportSourceExternalBindings$Outbound | null | undefined;
  heartbeats?: string | undefined;
  kubernetes?: ImportSourceKubernetes$Outbound | any | null | undefined;
  network?:
    | ImportSourceNetworkByoVpcAws$Outbound
    | ImportSourceNetworkByoVpcGcp$Outbound
    | ImportSourceNetworkByoVnetAzure$Outbound
    | ImportSourceNetworkUseDefault$Outbound
    | ImportSourceNetworkCreate$Outbound
    | any
    | null
    | undefined;
  publicEndpoints?: { [k: string]: { [k: string]: string } } | null | undefined;
  telemetry?: string | undefined;
  updates?: string | undefined;
};

/** @internal */
export const ImportSourceStackSettings$outboundSchema: z.ZodType<
  ImportSourceStackSettings$Outbound,
  ImportSourceStackSettings
> = z.object({
  compute: z.nullable(
    z.union([z.lazy(() => ImportSourceCompute$outboundSchema), z.any()]),
  ).optional(),
  deploymentModel: ImportSourceDeploymentModel$outboundSchema.optional(),
  domains: z.nullable(
    z.union([z.lazy(() => ImportSourceDomains$outboundSchema), z.any()]),
  ).optional(),
  externalBindings: z.nullable(
    z.lazy(() => ImportSourceExternalBindings$outboundSchema),
  ).optional(),
  heartbeats: ImportSourceHeartbeats$outboundSchema.optional(),
  kubernetes: z.nullable(
    z.union([z.lazy(() => ImportSourceKubernetes$outboundSchema), z.any()]),
  ).optional(),
  network: z.nullable(
    z.union([
      z.lazy(() => ImportSourceNetworkByoVpcAws$outboundSchema),
      z.lazy(() => ImportSourceNetworkByoVpcGcp$outboundSchema),
      z.lazy(() => ImportSourceNetworkByoVnetAzure$outboundSchema),
      z.lazy(() => ImportSourceNetworkUseDefault$outboundSchema),
      z.lazy(() => ImportSourceNetworkCreate$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  publicEndpoints: z.nullable(
    z.record(z.string(), z.record(z.string(), z.string())),
  ).optional(),
  telemetry: ImportSourceTelemetry$outboundSchema.optional(),
  updates: ImportSourceUpdates$outboundSchema.optional(),
});

export function importSourceStackSettingsToJSON(
  importSourceStackSettings: ImportSourceStackSettings,
): string {
  return JSON.stringify(
    ImportSourceStackSettings$outboundSchema.parse(importSourceStackSettings),
  );
}

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

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

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

export function importSourceManagementConfigKubernetesToJSON(
  importSourceManagementConfigKubernetes:
    ImportSourceManagementConfigKubernetes,
): string {
  return JSON.stringify(
    ImportSourceManagementConfigKubernetes$outboundSchema.parse(
      importSourceManagementConfigKubernetes,
    ),
  );
}

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

/** @internal */
export type ImportSourceManagementConfigAzure$Outbound = {
  managingTenantId: string;
  oidcIssuer: string;
  oidcSubject: string;
  platform: string;
};

/** @internal */
export const ImportSourceManagementConfigAzure$outboundSchema: z.ZodType<
  ImportSourceManagementConfigAzure$Outbound,
  ImportSourceManagementConfigAzure
> = z.object({
  managingTenantId: z.string(),
  oidcIssuer: z.string(),
  oidcSubject: z.string(),
  platform: ImportSourcePlatformAzure$outboundSchema,
});

export function importSourceManagementConfigAzureToJSON(
  importSourceManagementConfigAzure: ImportSourceManagementConfigAzure,
): string {
  return JSON.stringify(
    ImportSourceManagementConfigAzure$outboundSchema.parse(
      importSourceManagementConfigAzure,
    ),
  );
}

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

/** @internal */
export type ImportSourceManagementConfigGcp$Outbound = {
  serviceAccountEmail: string;
  platform: string;
};

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

export function importSourceManagementConfigGcpToJSON(
  importSourceManagementConfigGcp: ImportSourceManagementConfigGcp,
): string {
  return JSON.stringify(
    ImportSourceManagementConfigGcp$outboundSchema.parse(
      importSourceManagementConfigGcp,
    ),
  );
}

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

/** @internal */
export type ImportSourceManagementConfigAws$Outbound = {
  managingRoleArn: string;
  platform: string;
};

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

export function importSourceManagementConfigAwsToJSON(
  importSourceManagementConfigAws: ImportSourceManagementConfigAws,
): string {
  return JSON.stringify(
    ImportSourceManagementConfigAws$outboundSchema.parse(
      importSourceManagementConfigAws,
    ),
  );
}

/** @internal */
export type ImportSourceManagementConfigUnion$Outbound =
  | ImportSourceManagementConfigAzure$Outbound
  | ImportSourceManagementConfigAws$Outbound
  | ImportSourceManagementConfigGcp$Outbound
  | ImportSourceManagementConfigKubernetes$Outbound
  | any;

/** @internal */
export const ImportSourceManagementConfigUnion$outboundSchema: z.ZodType<
  ImportSourceManagementConfigUnion$Outbound,
  ImportSourceManagementConfigUnion
> = z.union([
  z.lazy(() => ImportSourceManagementConfigAzure$outboundSchema),
  z.lazy(() => ImportSourceManagementConfigAws$outboundSchema),
  z.lazy(() => ImportSourceManagementConfigGcp$outboundSchema),
  z.lazy(() => ImportSourceManagementConfigKubernetes$outboundSchema),
  z.any(),
]);

export function importSourceManagementConfigUnionToJSON(
  importSourceManagementConfigUnion: ImportSourceManagementConfigUnion,
): string {
  return JSON.stringify(
    ImportSourceManagementConfigUnion$outboundSchema.parse(
      importSourceManagementConfigUnion,
    ),
  );
}

/** @internal */
export type ImportSource$Outbound = {
  deploymentName: string;
  resourcePrefix: string;
  sourceKind?: string | undefined;
  setupMetadata?: { [k: string]: any | null } | undefined;
  releaseId?: string | undefined;
  platform: string;
  basePlatform?: string | undefined;
  region: string;
  setupTarget: string;
  setupImportFormatVersion: number;
  setupFingerprint: string;
  setupFingerprintVersion: number;
  stackSettings: ImportSourceStackSettings$Outbound;
  managementConfig?:
    | ImportSourceManagementConfigAzure$Outbound
    | ImportSourceManagementConfigAws$Outbound
    | ImportSourceManagementConfigGcp$Outbound
    | ImportSourceManagementConfigKubernetes$Outbound
    | any
    | null
    | undefined;
  resources: Array<ImportedResource$Outbound>;
};

/** @internal */
export const ImportSource$outboundSchema: z.ZodType<
  ImportSource$Outbound,
  ImportSource
> = z.object({
  deploymentName: z.string(),
  resourcePrefix: z.string(),
  sourceKind: ImportSourceKind$outboundSchema.optional(),
  setupMetadata: z.record(z.string(), z.nullable(z.any())).optional(),
  releaseId: z.string().optional(),
  platform: ImportSourcePlatform$outboundSchema,
  basePlatform: KubernetesBasePlatform$outboundSchema.optional(),
  region: z.string(),
  setupTarget: z.string(),
  setupImportFormatVersion: z.int(),
  setupFingerprint: z.string(),
  setupFingerprintVersion: z.int(),
  stackSettings: z.lazy(() => ImportSourceStackSettings$outboundSchema),
  managementConfig: z.nullable(
    z.union([
      z.lazy(() => ImportSourceManagementConfigAzure$outboundSchema),
      z.lazy(() => ImportSourceManagementConfigAws$outboundSchema),
      z.lazy(() => ImportSourceManagementConfigGcp$outboundSchema),
      z.lazy(() => ImportSourceManagementConfigKubernetes$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  resources: z.array(ImportedResource$outboundSchema),
});

export function importSourceToJSON(importSource: ImportSource): string {
  return JSON.stringify(ImportSource$outboundSchema.parse(importSource));
}